@proofchain/sdk 1.2.0 → 2.1.0

package/dist/index.d.mts

@@ -1,328 +1,2578 @@
-import { Signer, Provider, ContractTransactionResponse } from 'ethers';
-
-interface ChallengeRequest {
-    wallet_address: string;
-}
-interface VerifyRequest {
-    wallet_address: string;
-    signature: string;
-    message: string;
+/**
+ * HTTP Client for ProofChain API
+ */
+interface HttpClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
 }
-interface EventCreate {
-    user_id: string;
-    event_type: string;
-    data: Record<string, unknown>;
+declare class HttpClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    private maxRetries;
+    constructor(options: HttpClientOptions);
+    private getHeaders;
+    private handleResponse;
+    private fetchWithRetry;
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        params?: Record<string, string | number | undefined>;
+    }): Promise<T>;
+    requestMultipart<T>(path: string, formData: FormData): Promise<T>;
+    getRaw(path: string): Promise<ArrayBuffer>;
+    get<T>(path: string, params?: Record<string, string | number | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
 }
-interface EventQuery {
-    event_types?: string[];
-    start_time?: string;
-    end_time?: string;
-    include_invalidated?: boolean;
+
+/**
+ * ProofChain SDK Types
+ */
+type AttestationMode = 'direct' | 'batch' | 'channel';
+type EventStatus = 'pending' | 'queued' | 'confirmed' | 'settled' | 'failed';
+type ChannelState = 'open' | 'syncing' | 'settling' | 'settled' | 'closed';
+interface AttestationResult {
+    id: string;
+    ipfsHash: string;
+    documentHash: string;
+    gatewayUrl: string;
+    verifyUrl: string;
+    certificateId: string;
+    status: EventStatus;
+    attestationMode: AttestationMode;
+    timestamp: string;
+    blockchainTx?: string;
+    proof?: string[];
 }
-interface VerifyProofRequest {
-    leaf: string;
-    proof: string[];
-    root: string;
+interface Event {
+    id: string;
+    eventType: string;
+    userId: string;
+    ipfsHash: string;
+    documentHash?: string;
+    gatewayUrl: string;
+    certificateId: string;
+    status: EventStatus;
+    attestationMode: AttestationMode;
+    timestamp: string;
+    data?: Record<string, unknown>;
+    blockchainTx?: string;
+    batchId?: string;
+    channelId?: string;
 }
-interface LinkWalletRequest {
-    user_id: string;
-    wallet_address: string;
-    is_primary?: boolean;
+interface Channel {
+    channelId: string;
+    name: string;
+    state: ChannelState;
+    createdAt: string;
 }
-interface HealthResponse {
-    status: string;
-    timestamp: string;
+interface ChannelStatus {
+    channelId: string;
+    name: string;
+    state: ChannelState;
+    eventCount: number;
+    syncedCount: number;
+    pendingCount: number;
+    createdAt: string;
+    lastActivity?: string;
+    lastSettlement?: string;
+    merkleRoot?: string;
 }
-interface ChallengeResponse {
-    message: string;
-    nonce: string;
-    expires_at: string;
+interface Settlement {
+    channelId: string;
+    txHash: string;
+    merkleRoot: string;
+    eventCount: number;
+    blockNumber: number;
+    gasUsed: number;
+    settledAt: string;
 }
-interface AuthResponse {
-    access_token: string;
-    token_type: string;
-    expires_in: number;
-    wallet_address: string;
+interface Certificate {
+    certificateId: string;
+    recipientName: string;
+    recipientEmail?: string;
+    title: string;
+    description?: string;
+    ipfsHash: string;
+    verifyUrl: string;
+    qrCodeUrl: string;
+    issuedAt: string;
+    expiresAt?: string;
+    revoked: boolean;
+    revokedAt?: string;
+    revocationReason?: string;
+    metadata?: Record<string, unknown>;
+    blockchainTx?: string;
 }
-interface Event {
+interface Webhook {
     id: string;
-    user_id: string;
-    event_type: string;
-    ipfs_hash: string;
-    timestamp: string;
-    invalidated: boolean;
-    gateway_url?: string;
-    data?: Record<string, unknown>;
+    url: string;
+    events: string[];
+    active: boolean;
+    createdAt: string;
+    lastTriggered?: string;
+    failureCount: number;
 }
-interface EventsListResponse {
-    events: Event[];
+interface VerificationResult {
+    valid: boolean;
+    ipfsHash: string;
+    documentHash?: string;
+    timestamp?: string;
+    certificateId?: string;
+    blockchainTx?: string;
+    blockNumber?: number;
+    attestationMode?: AttestationMode;
+    proofVerified: boolean;
+    message: string;
+}
+interface SearchResult {
     total: number;
+    page: number;
     limit: number;
-    offset: number;
+    events: Event[];
 }
-interface MerkleTree {
-    user_id: string;
-    root: string | null;
-    event_count: number;
-    rebuilt_at?: string;
+interface UsageStats {
+    periodStart: string;
+    periodEnd: string;
+    eventsCreated: number;
+    documentsAttested: number;
+    verifications: number;
+    apiCalls: number;
+    storageBytes: number;
+    channelsCreated: number;
+    settlements: number;
 }
-interface MerkleProof {
-    user_id: string;
-    ipfs_hash: string;
-    leaf: string;
-    proof: string[];
-    root: string;
-    index: number;
-    event_type?: string;
-    timestamp?: number;
+interface TenantInfo {
+    tenantId: string;
+    name: string;
+    subdomain: string;
+    plan: string;
+    createdAt: string;
+    apiKeysCount: number;
+    eventsCount: number;
+    storageUsedBytes: number;
 }
-interface VerifyProofResponse {
-    valid: boolean;
-    leaf: string;
-    root: string;
+interface StreamAck {
+    sequence: number;
+    channelId: string;
+    received: boolean;
 }
-interface Wallet {
-    wallet_address: string;
-    user_id: string;
-    is_primary: boolean;
-    linked_at: string;
-    merkle_root?: string;
-    onchain_root?: string;
-    onchain_synced?: boolean;
+interface AttestRequest {
+    file: File | Blob | Buffer | ArrayBuffer;
+    filename?: string;
+    userId: string;
+    eventType?: string;
+    metadata?: Record<string, unknown>;
+    encrypt?: boolean;
 }
-interface WalletStatus {
-    user_id: string;
-    wallets: Wallet[];
-    merkle_root: string | null;
-    onchain_synced: boolean;
+interface CreateEventRequest {
+    eventType: string;
+    userId: string;
+    data?: Record<string, unknown>;
+    source?: string;
 }
-interface AttestationClientConfig {
-    baseUrl: string;
-    accessToken?: string;
-    timeout?: number;
+interface ListEventsRequest {
+    userId?: string;
+    eventType?: string;
+    status?: string;
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+    offset?: number;
 }
-interface RequestOptions {
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
+interface SearchRequest {
+    query: string;
+    userId?: string;
+    eventType?: string;
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+    page?: number;
 }
-interface QuestStep {
-    id: string;
+interface CreateChannelRequest {
     name: string;
     description?: string;
-    order: number;
-    step_type: 'event_count' | 'event_match' | 'unique_values' | 'cumulative' | 'streak' | 'manual';
-    event_type?: string;
-    event_types?: string[];
-    criteria?: Record<string, unknown>;
-    required_data_fields?: Record<string, unknown>;
-    step_points?: number;
-    icon_url?: string;
-    is_optional: boolean;
 }
-interface Quest {
-    id: string;
-    name: string;
-    slug: string;
+interface StreamEventRequest {
+    eventType: string;
+    userId: string;
+    data?: Record<string, unknown>;
+    source?: string;
+}
+interface IssueCertificateRequest {
+    recipientName: string;
+    recipientEmail?: string;
+    title: string;
     description?: string;
-    short_description?: string;
-    icon_url?: string;
-    banner_url?: string;
-    category?: string;
-    difficulty?: 'easy' | 'medium' | 'hard' | 'legendary';
-    estimated_time?: string;
-    status: 'draft' | 'active' | 'paused' | 'ended' | 'archived';
-    is_ordered: boolean;
-    is_repeatable: boolean;
-    is_available: boolean;
-    total_steps: number;
-    starts_at?: string;
-    ends_at?: string;
-    time_limit_hours?: number;
-    max_participants?: number;
-    current_participants: number;
-    max_completions?: number;
-    current_completions: number;
-    reward_points?: number;
-    is_public: boolean;
-    is_featured: boolean;
-    tags: string[];
-    steps: QuestStep[];
-    created_at: string;
+    metadata?: Record<string, unknown>;
+    expiresAt?: string;
+}
+interface ListCertificatesRequest {
+    recipientEmail?: string;
+    limit?: number;
+    offset?: number;
+}
+interface CreateWebhookRequest {
+    url: string;
+    events: string[];
+    secret?: string;
+}
+interface UpdateWebhookRequest {
+    url?: string;
+    events?: string[];
+    active?: boolean;
 }
-interface RewardInfo {
+interface VaultFile {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    ipfsHash: string;
+    userId: string;
+    folderId?: string;
+    accessMode: 'private' | 'public' | 'shared';
+    createdAt: string;
+    updatedAt?: string;
+}
+interface VaultFolder {
     id: string;
     name: string;
-    description?: string;
-    type: 'points' | 'nft' | 'badge' | 'coupon' | 'custom';
-    image_url?: string;
-    issued_at?: string;
-    claimed: boolean;
-    claim_url?: string;
-    metadata: Record<string, unknown>;
+    parentId?: string;
+    createdAt: string;
 }
-interface UserQuestProgress {
+interface VaultListResponse {
+    files: VaultFile[];
+    folders: VaultFolder[];
+    totalFiles: number;
+    totalSize: number;
+}
+interface VaultStats {
+    totalFiles: number;
+    totalFolders: number;
+    totalSize: number;
+    usedQuota: number;
+    maxQuota: number;
+}
+interface VaultUploadRequest {
+    file: File | Blob | Buffer | ArrayBuffer;
+    filename?: string;
+    userId: string;
+    folderId?: string;
+    accessMode?: 'private' | 'public' | 'shared';
+}
+interface SearchFilters {
+    query?: string;
+    eventTypes?: string[];
+    eventSources?: string[];
+    userIds?: string[];
+    status?: string;
+    hasDocument?: boolean;
+    hasBlockchainProof?: boolean;
+    fromDate?: string;
+    toDate?: string;
+}
+interface SearchQueryRequest {
+    filters?: SearchFilters;
+    offset?: number;
+    limit?: number;
+    includeData?: boolean;
+}
+interface SearchResponse {
+    total: number;
+    offset: number;
+    limit: number;
+    results: Event[];
+}
+interface Facet {
+    key: string;
+    count: number;
+}
+interface FacetsResponse {
+    eventTypes: Facet[];
+    eventSources: Facet[];
+    statuses: Facet[];
+    users: Facet[];
+}
+interface SearchStats {
+    periodDays: number;
+    totalEvents: number;
+    uniqueUsers: number;
+    eventsPerDay: number;
+    totalStorageBytes: number;
+}
+interface CertificateVerifyResult {
+    certificateId: string;
+    status: 'VALID' | 'REVOKED' | 'EXPIRED' | 'NOT_FOUND';
+    recipientName: string;
+    title: string;
+    issuedAt: string;
+    expiresAt?: string;
+    revokedAt?: string;
+    revocationReason?: string;
+    ipfsHash: string;
+    verifyUrl: string;
+    blockchain?: Record<string, unknown>;
+}
+interface ProofVerifyResult {
+    valid: boolean;
+    message: string;
+    verifiedAt: string;
+}
+interface BatchVerifyResult {
+    batchId: string;
+    merkleRoot: string;
+    totalEvents: number;
+    blockchainTx?: string;
+    blockNumber?: number;
+    verified: boolean;
+}
+interface EventBatchProof {
+    eventId: string;
+    certificateId: string;
+    batchId: string;
+    leafIndex: number;
+    merkleProof: string[];
+    merkleRoot: string;
+    blockchainTx?: string;
+    verified: boolean;
+}
+interface ApiKey {
     id: string;
-    quest_id: string;
-    user_id: string;
-    status: 'not_started' | 'in_progress' | 'completed' | 'reward_pending' | 'reward_issued' | 'expired' | 'abandoned';
-    current_step: number;
-    steps_completed: number;
-    total_steps: number;
-    completion_percentage: number;
-    points_earned: number;
-    step_progress: Record<string, {
-        count: number;
-        unique_values?: string[];
-        completed?: boolean;
-        completed_at?: string;
-    }>;
-    started_at?: string;
-    completed_at?: string;
-    expires_at?: string;
-    completion_count: number;
-    reward_earned_id?: string;
-    reward_issued_at?: string;
-    reward?: RewardInfo;
-}
-interface QuestWithProgress {
-    quest: Quest;
-    progress?: UserQuestProgress;
-}
-interface QuestStepCompletionResult {
-    step_index: number;
-    step_completed: boolean;
-    quest_completed: boolean;
-    current_count: number;
-    target_count: number;
-    points_earned: number;
+    name: string;
+    keyPrefix: string;
+    permissions: string[];
+    createdAt: string;
+    lastUsedAt?: string;
+    expiresAt?: string;
+    isActive: boolean;
+    key?: string;
 }
+interface BlockchainStats {
+    totalTransactions: number;
+    totalGasUsed: number;
+    totalEventsAttested: number;
+    pendingEvents: number;
+    lastTransaction?: string;
+    contractAddress?: string;
+    chainId: number;
+    chainName: string;
+}
+interface BlockchainProof {
+    certificateId: string;
+    verified: boolean;
+    txHash?: string;
+    blockNumber?: number;
+    merkleRoot?: string;
+    merkleProof?: string[];
+    leafIndex?: number;
+    chainName: string;
+}
+interface CreateApiKeyRequest {
+    name: string;
+    permissions?: string[];
+    expiresInDays?: number;
+}
+interface ProofChainOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+
+/**
+ * Vault Resource - File storage operations
+ */
 
-declare class AttestationClientError extends Error {
-    status: number;
-    body?: unknown | undefined;
-    constructor(message: string, status: number, body?: unknown | undefined);
+declare class VaultResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List files and folders in the vault.
+     */
+    list(folderId?: string): Promise<VaultListResponse>;
+    /**
+     * Upload a file to the vault.
+     */
+    upload(request: VaultUploadRequest): Promise<VaultFile>;
+    /**
+     * Get file details.
+     */
+    get(fileId: string): Promise<VaultFile>;
+    /**
+     * Download a file.
+     */
+    download(fileId: string): Promise<ArrayBuffer>;
+    /**
+     * Delete a file.
+     */
+    delete(fileId: string): Promise<void>;
+    /**
+     * Move a file to a folder.
+     */
+    move(fileId: string, folderId: string): Promise<VaultFile>;
+    /**
+     * Create a folder.
+     */
+    createFolder(name: string, parentId?: string): Promise<VaultFolder>;
+    /**
+     * Delete a folder.
+     */
+    deleteFolder(folderId: string): Promise<void>;
+    /**
+     * Get vault statistics.
+     */
+    stats(): Promise<VaultStats>;
+    /**
+     * Create a shareable link.
+     */
+    share(fileId: string, expiresInHours?: number): Promise<{
+        url: string;
+        expiresAt: string;
+    }>;
 }
-declare class AttestationClient {
-    private baseUrl;
-    private accessToken?;
-    private timeout;
-    constructor(config: AttestationClientConfig);
-    private request;
-    setAccessToken(token: string): void;
-    clearAccessToken(): void;
-    health(): Promise<HealthResponse>;
-    requestChallenge(walletAddress: string): Promise<ChallengeResponse>;
-    verifySignature(walletAddress: string, signature: string, message: string): Promise<AuthResponse>;
-    createEvent(event: EventCreate): Promise<Event>;
-    getEvents(userId: string, options?: {
-        limit?: number;
-        offset?: number;
-        eventType?: string;
-        fetchData?: boolean;
-    }): Promise<EventsListResponse>;
-    queryEvents(userId: string, query: EventQuery): Promise<EventsListResponse>;
-    rebuildMerkleTree(userId: string): Promise<MerkleTree>;
-    getMerkleRoot(userId: string): Promise<MerkleTree>;
-    getMerkleProof(userId: string, ipfsHash: string): Promise<MerkleProof>;
-    verifyMerkleProof(leaf: string, proof: string[], root: string): Promise<VerifyProofResponse>;
-    linkWallet(request: LinkWalletRequest): Promise<Wallet>;
-    getWalletStatus(userId: string): Promise<WalletStatus>;
-    /**
-     * List available quests for a user
-     * @param userId - End user external ID
-     * @param options - Filter options
-     */
-    getAvailableQuests(userId: string, options?: {
-        category?: string;
-        limit?: number;
-    }): Promise<QuestWithProgress[]>;
+
+/**
+ * Search Resource - Advanced search operations
+ */
+
+declare class SearchResource {
+    private http;
+    constructor(http: HttpClient);
     /**
-     * Get a specific quest by ID with all steps
-     * @param questId - Quest ID
+     * Search events with filters.
      */
-    getQuest(questId: string): Promise<Quest>;
+    query(request?: SearchQueryRequest): Promise<SearchResponse>;
     /**
-     * Start a quest for a user
-     * @param questId - Quest ID
-     * @param userId - End user external ID
+     * Quick search across all fields.
      */
-    startQuest(questId: string, userId: string): Promise<UserQuestProgress>;
+    quick(query: string, limit?: number): Promise<SearchResponse>;
     /**
-     * Get user's progress on a specific quest
-     * @param questId - Quest ID
-     * @param userId - End user external ID
+     * Get events for a specific user.
      */
-    getQuestProgress(questId: string, userId: string): Promise<UserQuestProgress>;
+    byUser(userId: string, limit?: number, offset?: number): Promise<SearchResponse>;
     /**
-     * Get all quest progress for a user
-     * @param userId - End user external ID
-     * @param status - Optional status filter
+     * Get event by certificate ID.
+     */
+    byCertificate(certificateId: string): Promise<Event>;
+    /**
+     * Get faceted aggregations.
      */
-    getUserQuestProgress(userId: string, status?: string): Promise<UserQuestProgress[]>;
+    facets(fromDate?: string, toDate?: string): Promise<FacetsResponse>;
     /**
-     * Complete or increment a quest step
-     * @param questId - Quest ID
-     * @param userId - End user external ID
-     * @param stepIndex - Step index (0-based)
-     * @param options - Completion options
+     * Get search statistics.
      */
-    completeQuestStep(questId: string, userId: string, stepIndex: number, options?: {
-        count?: number;
-        value?: string;
-    }): Promise<QuestStepCompletionResult>;
+    stats(): Promise<SearchStats>;
 }
 
-interface AttestationRoot {
-    merkleRoot: string;
-    eventCount: bigint;
-    lastUpdated: bigint;
-    latestIpfsHash: string;
+/**
+ * Verify Resource - Public verification operations
+ */
+
+declare class VerifyResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Verify a certificate by ID.
+     */
+    certificate(certificateId: string): Promise<CertificateVerifyResult>;
+    /**
+     * Verify an event by IPFS hash.
+     */
+    event(ipfsHash: string): Promise<Record<string, unknown>>;
+    /**
+     * Verify a Merkle proof.
+     */
+    proof(leaf: string, proof: string[], root: string): Promise<ProofVerifyResult>;
+    /**
+     * Verify a batch by ID.
+     */
+    batch(batchId: string): Promise<BatchVerifyResult>;
+    /**
+     * Get batch proof for an event.
+     */
+    eventBatchProof(eventId: string): Promise<EventBatchProof>;
+    /**
+     * Batch verify multiple items.
+     */
+    batchVerify(items: Array<{
+        type: string;
+        id: string;
+    }>): Promise<Record<string, unknown>>;
 }
-interface RootHistory {
-    merkleRoot: string;
-    eventCount: bigint;
-    timestamp: bigint;
-}
-interface RootUpdatedEvent {
-    wallet: string;
-    newRoot: string;
-    previousRoot: string;
-    eventCount: bigint;
-    latestIpfsHash: string;
-}
-declare class AttestationRegistryContract {
-    private contract;
-    private signer?;
-    constructor(contractAddress: string, signerOrProvider: Signer | Provider);
-    getRoot(wallet: string): Promise<AttestationRoot>;
-    getHistoryCount(wallet: string): Promise<bigint>;
-    getHistoricalRoot(wallet: string, index: number): Promise<RootHistory>;
-    verifyAttestation(wallet: string, leaf: string, proof: string[]): Promise<boolean>;
-    computeLeaf(ipfsHash: string, eventType: string, timestamp: number): Promise<string>;
-    getWalletByIpfsHash(ipfsHash: string): Promise<string>;
-    isAuthorizedUpdater(address: string): Promise<boolean>;
-    owner(): Promise<string>;
-    updateRoot(wallet: string, newRoot: string, eventCount: number, latestIpfsHash: string): Promise<ContractTransactionResponse>;
-    batchUpdateRoots(wallets: string[], roots: string[], eventCounts: number[], ipfsHashes: string[]): Promise<ContractTransactionResponse>;
-    setAuthorizedUpdater(updater: string, authorized: boolean): Promise<ContractTransactionResponse>;
-    onRootUpdated(callback: (event: RootUpdatedEvent) => void, filter?: {
-        wallet?: string;
-    }): void;
-    removeAllListeners(): void;
-    static computeLeafOffchain(ipfsHash: string, eventType: string, timestamp: number): string;
-    static verifyProofOffchain(leaf: string, proof: string[], root: string): boolean;
+
+/**
+ * Tenant Resource - Tenant management operations
+ */
+
+declare class TenantResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all API keys.
+     */
+    listApiKeys(): Promise<ApiKey[]>;
+    /**
+     * Create a new API key.
+     */
+    createApiKey(request: CreateApiKeyRequest): Promise<ApiKey>;
+    /**
+     * Delete an API key.
+     */
+    deleteApiKey(keyId: string): Promise<void>;
+    /**
+     * Get detailed usage statistics.
+     */
+    usageDetailed(fromDate?: string, toDate?: string): Promise<Record<string, unknown>>;
+    /**
+     * Get tenant context.
+     */
+    context(): Promise<Record<string, unknown>>;
+    /**
+     * Get blockchain statistics.
+     */
+    blockchainStats(): Promise<BlockchainStats>;
+    /**
+     * Verify a certificate on the blockchain.
+     */
+    blockchainVerify(certificateId: string): Promise<BlockchainProof>;
+    /**
+     * List blockchain certificates.
+     */
+    blockchainCertificates(limit?: number, offset?: number): Promise<Record<string, unknown>>;
+    /**
+     * Force batch settlement.
+     */
+    forceBatch(): Promise<Record<string, unknown>>;
+    /**
+     * Settle all pending events.
+     */
+    settleAll(): Promise<Record<string, unknown>>;
+    /**
+     * Settle a specific event.
+     */
+    settleEvent(eventId: string): Promise<Record<string, unknown>>;
 }
 
 /**
- * Copyright (c) 2024-2025 Clive Watts / MegaWatts Solutions
- * All Rights Reserved.
+ * Passport API Client
  *
- * PROPRIETARY AND CONFIDENTIAL
- * This software is the exclusive property of MegaWatts Solutions.
- * Unauthorized copying, distribution, or use is strictly prohibited.
- * See LICENSE file for full terms.
+ * Manage user passports, templates, badges, and achievements.
  */
 
-declare function createClient(baseUrl: string, accessToken?: string): AttestationClient;
+interface Passport {
+    id: string;
+    tenant_id: string;
+    user_id: string;
+    wallet_address?: string;
+    level: number;
+    points: number;
+    experience: number;
+    traits: Record<string, any>;
+    custom_metadata: Record<string, any>;
+    on_chain_token_id?: string;
+    on_chain_tx_hash?: string;
+    created_at: string;
+    last_updated_at: string;
+}
+interface PassportWithFields extends Passport {
+    template_id?: string;
+    template_name?: string;
+    field_values: FieldValue[];
+}
+interface FieldValue {
+    field_key: string;
+    field_name: string;
+    value: any;
+    data_type: string;
+    computed_at?: string;
+    manually_set: boolean;
+}
+interface PassportTemplate {
+    id: string;
+    tenant_id: string;
+    name: string;
+    description?: string;
+    slug: string;
+    icon_url?: string;
+    is_default: boolean;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    fields: TemplateField[];
+}
+interface TemplateField {
+    id: string;
+    template_id: string;
+    name: string;
+    field_key: string;
+    description?: string;
+    data_type: string;
+    default_value?: any;
+    formula?: string;
+    formula_type?: string;
+    aggregation?: string;
+    event_filter?: Record<string, any>;
+    display_format?: string;
+    icon?: string;
+    color?: string;
+    sort_order: number;
+    is_visible: boolean;
+    is_computed: boolean;
+    created_at: string;
+}
+interface Badge {
+    id: string;
+    tenant_id: string;
+    badge_id: string;
+    name: string;
+    description?: string;
+    icon_url?: string;
+    rarity: string;
+    requirements: Record<string, any>;
+    created_at: string;
+}
+interface Achievement {
+    id: string;
+    tenant_id: string;
+    achievement_id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    points_reward: number;
+    requirements: Record<string, any>;
+    created_at: string;
+}
+interface UserBadge {
+    id: string;
+    passport_id: string;
+    badge_id: string;
+    badge: Badge;
+    earned_at: string;
+    metadata?: Record<string, any>;
+}
+interface UserAchievement {
+    id: string;
+    passport_id: string;
+    achievement_id: string;
+    achievement: Achievement;
+    earned_at: string;
+    progress: number;
+    completed: boolean;
+}
+interface PassportHistory {
+    id: string;
+    passport_id: string;
+    event_type: string;
+    old_value?: any;
+    new_value?: any;
+    change_reason?: string;
+    created_at: string;
+}
+interface CreatePassportRequest {
+    user_id: string;
+    wallet_address?: string;
+    level?: number;
+    points?: number;
+    experience?: number;
+    traits?: Record<string, any>;
+    custom_metadata?: Record<string, any>;
+}
+interface UpdatePassportRequest {
+    wallet_address?: string;
+    level?: number;
+    points?: number;
+    experience?: number;
+    traits?: Record<string, any>;
+    custom_metadata?: Record<string, any>;
+}
+interface CreateTemplateRequest {
+    name: string;
+    description?: string;
+    slug: string;
+    icon_url?: string;
+    is_default?: boolean;
+    fields?: CreateTemplateFieldRequest[];
+}
+interface CreateTemplateFieldRequest {
+    name: string;
+    field_key: string;
+    description?: string;
+    data_type?: string;
+    default_value?: any;
+    formula?: string;
+    formula_type?: string;
+    aggregation?: string;
+    event_filter?: Record<string, any>;
+    display_format?: string;
+    icon?: string;
+    color?: string;
+    sort_order?: number;
+    is_visible?: boolean;
+    is_computed?: boolean;
+}
+interface CreateBadgeRequest {
+    badge_id: string;
+    name: string;
+    description?: string;
+    icon_url?: string;
+    rarity?: string;
+    requirements?: Record<string, any>;
+}
+interface CreateAchievementRequest {
+    achievement_id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    points_reward?: number;
+    requirements?: Record<string, any>;
+}
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+}
+declare class PassportClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all passports for the tenant
+     */
+    list(options?: ListOptions): Promise<Passport[]>;
+    /**
+     * Get a passport by user ID
+     */
+    get(userId: string): Promise<Passport>;
+    /**
+     * Get a passport with all field values
+     */
+    getWithFields(userId: string): Promise<PassportWithFields>;
+    /**
+     * Create a new passport for a user
+     */
+    create(data: CreatePassportRequest): Promise<Passport>;
+    /**
+     * Update a passport
+     */
+    update(userId: string, data: UpdatePassportRequest): Promise<Passport>;
+    /**
+     * Delete a passport
+     */
+    delete(userId: string): Promise<void>;
+    /**
+     * Add points to a passport
+     */
+    addPoints(userId: string, points: number, reason?: string): Promise<Passport>;
+    /**
+     * Level up a passport
+     */
+    levelUp(userId: string): Promise<Passport>;
+    /**
+     * Link a wallet address to a passport
+     */
+    linkWallet(userId: string, walletAddress: string): Promise<Passport>;
+    /**
+     * Get all field values for a passport
+     */
+    getFieldValues(userId: string): Promise<FieldValue[]>;
+    /**
+     * Set a field value manually
+     */
+    setFieldValue(userId: string, fieldKey: string, value: any): Promise<void>;
+    /**
+     * Recompute all computed field values
+     */
+    recomputeFields(userId: string): Promise<{
+        updated_fields: Record<string, any>;
+    }>;
+    /**
+     * Assign a template to a passport
+     */
+    assignTemplate(userId: string, templateId: string): Promise<void>;
+    /**
+     * List all passport templates
+     */
+    listTemplates(): Promise<PassportTemplate[]>;
+    /**
+     * Get a template by ID
+     */
+    getTemplate(templateId: string): Promise<PassportTemplate>;
+    /**
+     * Create a new template
+     */
+    createTemplate(data: CreateTemplateRequest): Promise<PassportTemplate>;
+    /**
+     * Add a field to a template
+     */
+    addTemplateField(templateId: string, field: CreateTemplateFieldRequest): Promise<TemplateField>;
+    /**
+     * Delete a template
+     */
+    deleteTemplate(templateId: string): Promise<void>;
+    /**
+     * List all badges
+     */
+    listBadges(): Promise<Badge[]>;
+    /**
+     * Create a badge
+     */
+    createBadge(data: CreateBadgeRequest): Promise<Badge>;
+    /**
+     * Award a badge to a user
+     */
+    awardBadge(userId: string, badgeId: string, metadata?: Record<string, any>): Promise<UserBadge>;
+    /**
+     * Get badges earned by a user
+     */
+    getUserBadges(userId: string): Promise<UserBadge[]>;
+    /**
+     * List all achievements
+     */
+    listAchievements(): Promise<Achievement[]>;
+    /**
+     * Create an achievement
+     */
+    createAchievement(data: CreateAchievementRequest): Promise<Achievement>;
+    /**
+     * Get achievements for a user
+     */
+    getUserAchievements(userId: string): Promise<UserAchievement[]>;
+    /**
+     * Update achievement progress
+     */
+    updateAchievementProgress(userId: string, achievementId: string, progress: number): Promise<UserAchievement>;
+    /**
+     * Get passport history/activity log
+     */
+    getHistory(userId: string, options?: ListOptions): Promise<PassportHistory[]>;
+    /**
+     * Get passport data for a user using Passport V2 API.
+     * This integrates with custom data views for dynamic computation.
+     *
+     * @param userId - The user ID
+     * @param passportId - Optional specific passport definition ID
+     * @returns Passport data with computed fields from data view
+     */
+    getPassportV2(userId: string, passportId?: string): Promise<PassportV2Data>;
+    /**
+     * Get passport view data for a user (alias for getPassportV2).
+     *
+     * @param userId - The user ID
+     * @param passportId - Optional specific passport definition ID
+     * @returns Passport data with computed fields from data view
+     */
+    getPassportView(userId: string, passportId?: string): Promise<PassportV2Data>;
+    /**
+     * Get user milestones from Passport V2.
+     *
+     * @param userId - The user ID
+     * @param passportId - Optional passport ID to filter milestones
+     * @returns List of milestones achieved by the user
+     */
+    getMilestones(userId: string, passportId?: string): Promise<Milestone[]>;
+    /**
+     * List available data views that can be used for passports.
+     * Includes built-in views and custom data views.
+     *
+     * @returns List of available views with their columns
+     */
+    listAvailableViews(): Promise<AvailableView[]>;
+    /**
+     * List passport definitions for the tenant.
+     *
+     * @returns List of passport definitions
+     */
+    listPassportDefinitions(): Promise<PassportDefinition[]>;
+    /**
+     * Create a new passport definition linked to a data view.
+     *
+     * @param definition - The passport definition to create
+     * @returns Created passport definition
+     *
+     * @example
+     * ```typescript
+     * const passport = await client.passports.createPassportDefinition({
+     *   name: 'Fan Engagement Passport',
+     *   description: 'Track fan engagement metrics',
+     *   data_view_id: 'builtin-fan-profile', // or custom view UUID
+     *   display_columns: ['fan_score', 'loyalty_tier', 'total_events'],
+     *   column_labels: {
+     *     fan_score: 'Engagement Score',
+     *     loyalty_tier: 'Tier',
+     *     total_events: 'Activities'
+     *   }
+     * });
+     * ```
+     */
+    createPassportDefinition(definition: CreatePassportDefinitionRequest): Promise<PassportDefinition>;
+}
+interface PassportV2Data {
+    user_id: string;
+    passport: PassportDefinition;
+    data: Record<string, PassportFieldValue>;
+    milestones: Milestone[];
+    generated_at: string;
+}
+interface PassportFieldValue {
+    label: string;
+    value: any;
+    format?: string;
+}
+interface PassportDefinition {
+    id: string;
+    tenant_id: string;
+    name: string;
+    description?: string;
+    slug?: string;
+    data_view_id?: string;
+    data_view_name?: string;
+    display_columns: string[];
+    column_labels: Record<string, string>;
+    column_formats: Record<string, string>;
+    is_default: boolean;
+    is_active: boolean;
+    is_public: boolean;
+    created_at: string;
+    threshold_count: number;
+}
+interface Milestone {
+    id: string;
+    name: string;
+    description?: string;
+    milestone_type: string;
+    icon_url?: string;
+    badge_color?: string;
+    points_reward: number;
+    triggered_at: string;
+    value_at_trigger?: any;
+}
+interface AvailableView {
+    id: string;
+    name: string;
+    view_name: string;
+    description?: string;
+    is_builtin: boolean;
+    is_custom_computation?: boolean;
+    view_type?: string;
+    columns: ViewColumn[];
+}
+interface ViewColumn {
+    name: string;
+    type: string;
+    computation_type?: string;
+}
+interface CreatePassportDefinitionRequest {
+    name: string;
+    description?: string;
+    slug?: string;
+    data_view_id?: string;
+    display_columns?: string[];
+    column_labels?: Record<string, string>;
+    column_formats?: Record<string, string>;
+    is_default?: boolean;
+    is_public?: boolean;
+}
+
+/**
+ * Wallet Management API Client
+ *
+ * Manage CDP wallets, NFTs, and token swaps for end-users.
+ */
+
+interface Wallet {
+    wallet_id: string;
+    address: string;
+    user_id: string;
+    wallet_type: 'eoa' | 'smart' | 'solana';
+    network: string;
+    name?: string;
+    status: string;
+    created_at: string;
+    metadata?: Record<string, any>;
+    supports_export?: boolean;
+    owner_wallet_id?: string;
+    is_deployed?: boolean;
+}
+interface DualWallets {
+    user_id: string;
+    asset_wallet: Wallet;
+    smart_wallet: Wallet;
+    network: string;
+}
+interface WalletBalance {
+    wallet_id: string;
+    address: string;
+    network: string;
+    balances: TokenBalance[];
+}
+interface TokenBalance {
+    token: string;
+    symbol: string;
+    balance: string;
+    decimals: number;
+    usd_value?: number;
+}
+interface NFT {
+    id: string;
+    wallet_id: string;
+    contract_address: string;
+    token_id: string;
+    network: string;
+    name?: string;
+    description?: string;
+    image_url?: string;
+    metadata?: Record<string, any>;
+    source: string;
+    acquired_at: string;
+}
+interface SwapQuote {
+    from_token: string;
+    to_token: string;
+    from_amount: string;
+    to_amount: string;
+    exchange_rate: string;
+    price_impact: string;
+    gas_estimate: string;
+    expires_at: string;
+}
+interface SwapResult {
+    transaction_hash: string;
+    status: string;
+    from_token: string;
+    to_token: string;
+    from_amount: string;
+    to_amount: string;
+    gas_used: string;
+}
+interface WalletStats {
+    total_wallets: number;
+    by_type: Record<string, number>;
+    by_network: Record<string, number>;
+}
+interface ComprehensiveWalletInfo {
+    wallet_id: string;
+    address: string;
+    user_id: string;
+    wallet_type: string;
+    network: string;
+    name?: string;
+    status: string;
+    supports_export: boolean;
+    created_at: string;
+    metadata?: Record<string, any>;
+    owner_wallet_id?: string;
+    owner_address?: string;
+    is_deployed?: boolean;
+    balances?: {
+        address: string;
+        network: string;
+        tokens: TokenBalance[];
+        fetched_at: string;
+    };
+    nfts?: {
+        total: number;
+        items: NFT[];
+    };
+    activity?: {
+        recent_swaps: SwapResult[];
+        total_swaps: number;
+    };
+}
+interface UserWalletSummary {
+    user_id: string;
+    total_wallets: number;
+    total_nfts: number;
+    total_swaps: number;
+    wallets: Array<{
+        wallet_id: string;
+        address: string;
+        wallet_type: string;
+        network: string;
+        name?: string;
+        supports_export: boolean;
+        created_at: string;
+        owner_wallet_id?: string;
+        is_deployed?: boolean;
+        balances?: {
+            address: string;
+            network: string;
+            tokens: TokenBalance[];
+            fetched_at: string;
+        };
+    }>;
+}
+interface CreateWalletRequest {
+    user_id: string;
+    wallet_type?: 'eoa' | 'smart' | 'solana';
+    network?: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+interface CreateDualWalletsRequest {
+    user_id: string;
+    network?: string;
+    name_prefix?: string;
+}
+interface SwapQuoteRequest {
+    from_token: string;
+    to_token: string;
+    from_amount: string;
+    network?: string;
+    slippage_bps?: number;
+}
+interface ExecuteSwapRequest {
+    wallet_id: string;
+    from_token: string;
+    to_token: string;
+    from_amount: string;
+    network?: string;
+    slippage_bps?: number;
+}
+interface AddNFTRequest {
+    contract_address: string;
+    token_id: string;
+    network: string;
+    metadata?: Record<string, any>;
+    source?: string;
+}
+interface TransferRequest {
+    from_address: string;
+    to_address: string;
+    amount: string;
+    token?: string;
+    network?: string;
+}
+interface TransferResult {
+    tx_hash: string;
+    from: string;
+    to: string;
+    amount: string;
+    token: string;
+    network: string;
+    status: string;
+}
+interface UserWithWallets {
+    user_id: string;
+    wallets: Array<{
+        wallet_id: string;
+        address: string;
+        wallet_type: string;
+        network: string;
+        name?: string;
+        status: string;
+    }>;
+}
+interface UsersWithWalletsResponse {
+    users: UserWithWallets[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+declare class WalletClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a single wallet for a user
+     */
+    create(data: CreateWalletRequest): Promise<Wallet>;
+    /**
+     * Get a wallet by ID
+     */
+    get(walletId: string): Promise<Wallet>;
+    /**
+     * List wallets for a user
+     */
+    listByUser(userId: string): Promise<Wallet[]>;
+    /**
+     * Get wallet statistics
+     */
+    stats(): Promise<WalletStats>;
+    /**
+     * List all users who have wallets, grouped by user_id.
+     *
+     * @param limit - Maximum number of users to return (default 50)
+     * @param offset - Offset for pagination (default 0)
+     * @returns List of users with their wallets
+     */
+    listUsersWithWallets(limit?: number, offset?: number): Promise<UsersWithWalletsResponse>;
+    /**
+     * Create dual wallets (EOA asset wallet + Smart Account) for a user
+     */
+    createDual(data: CreateDualWalletsRequest): Promise<DualWallets>;
+    /**
+     * Bulk create dual wallets for multiple users
+     */
+    createDualBulk(userIds: string[], network?: string): Promise<DualWallets[]>;
+    /**
+     * Get wallet balance
+     */
+    getBalance(walletId: string): Promise<WalletBalance>;
+    /**
+     * Get comprehensive wallet information in a single call.
+     *
+     * Returns everything about a wallet:
+     * - Basic wallet details (address, type, network)
+     * - Token balances (native + ERC20)
+     * - NFT holdings with metadata
+     * - Recent activity (swaps, transfers)
+     *
+     * @param walletId - Wallet ID to query
+     * @param options - Control what data is included
+     */
+    getInfo(walletId: string, options?: {
+        includeBalances?: boolean;
+        includeNfts?: boolean;
+        includeActivity?: boolean;
+    }): Promise<ComprehensiveWalletInfo>;
+    /**
+     * Get comprehensive summary of all wallets for a user.
+     *
+     * Returns all wallets (EOA + Smart) with aggregated stats:
+     * - Total NFTs across all wallets
+     * - Total swaps executed
+     * - Token balances (optional)
+     *
+     * @param userId - User ID to query
+     * @param includeBalances - Include token balances (requires Alchemy)
+     */
+    getUserSummary(userId: string, includeBalances?: boolean): Promise<UserWalletSummary>;
+    /**
+     * Export private key for an EOA wallet (requires acknowledgment)
+     */
+    exportKey(walletId: string): Promise<{
+        private_key: string;
+        warning: string;
+    }>;
+    /**
+     * Transfer tokens from one address to another.
+     *
+     * @param request - Transfer details
+     * @returns Transaction result with hash and status
+     *
+     * @example
+     * ```typescript
+     * const result = await client.wallets.transfer({
+     *   from_address: '0x123...',
+     *   to_address: '0x456...',
+     *   amount: '0.1',
+     *   token: 'ETH',
+     *   network: 'base-sepolia',
+     * });
+     * console.log('TX Hash:', result.tx_hash);
+     * ```
+     */
+    transfer(request: TransferRequest): Promise<TransferResult>;
+    /**
+     * Get a swap quote
+     */
+    getSwapQuote(request: SwapQuoteRequest): Promise<SwapQuote>;
+    /**
+     * Execute a token swap
+     */
+    executeSwap(request: ExecuteSwapRequest): Promise<SwapResult>;
+    /**
+     * Get NFTs for a wallet
+     */
+    getNFTs(walletId: string): Promise<NFT[]>;
+    /**
+     * Get all NFTs for a user (across all wallets)
+     */
+    getUserNFTs(userId: string): Promise<NFT[]>;
+    /**
+     * Add an NFT to wallet tracking
+     */
+    addNFT(walletId: string, nft: AddNFTRequest): Promise<NFT>;
+}
+
+/**
+ * End Users API Client
+ *
+ * Manage end-users discovered from events - profiles, segments, and activity.
+ */
+
+interface EndUser {
+    id: string;
+    external_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    display_name?: string;
+    avatar_url?: string;
+    phone?: string;
+    date_of_birth?: string;
+    country?: string;
+    city?: string;
+    timezone?: string;
+    language?: string;
+    bio?: string;
+    wallet_address?: string;
+    wallet_source?: string;
+    status: string;
+    total_events: number;
+    first_event_at?: string;
+    last_event_at?: string;
+    event_types: string[];
+    segments: string[];
+    tags: Record<string, any>;
+    points_balance: number;
+    lifetime_points: number;
+    attributes: Record<string, any>;
+    created_at: string;
+    discovered_at?: string;
+}
+interface EndUserListResponse {
+    users: EndUser[];
+    total: number;
+    page: number;
+    page_size: number;
+    has_more: boolean;
+}
+interface UserActivity {
+    event_id: string;
+    event_type: string;
+    timestamp: string;
+    data: Record<string, any>;
+}
+interface UserActivityResponse {
+    user_id: string;
+    activities: UserActivity[];
+    total: number;
+    page: number;
+    page_size: number;
+}
+interface CreateEndUserRequest {
+    external_id: string;
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    display_name?: string;
+    phone?: string;
+    date_of_birth?: string;
+    country?: string;
+    city?: string;
+    timezone?: string;
+    language?: string;
+    bio?: string;
+    wallet_address?: string;
+    segments?: string[];
+    tags?: Record<string, any>;
+    attributes?: Record<string, any>;
+}
+interface UpdateEndUserRequest {
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+    display_name?: string;
+    avatar_url?: string;
+    phone?: string;
+    date_of_birth?: string;
+    country?: string;
+    city?: string;
+    timezone?: string;
+    language?: string;
+    bio?: string;
+    segments?: string[];
+    tags?: Record<string, any>;
+    attributes?: Record<string, any>;
+}
+interface ListEndUsersOptions {
+    page?: number;
+    page_size?: number;
+    search?: string;
+    status?: string;
+    segment?: string;
+    has_wallet?: boolean;
+    sort_by?: string;
+    sort_order?: 'asc' | 'desc';
+}
+interface LinkWalletRequest {
+    wallet_address: string;
+    wallet_source?: string;
+    signature?: string;
+}
+interface MergeUsersRequest {
+    source_user_id: string;
+    target_user_id: string;
+}
+declare class EndUsersClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List end-users with pagination and filters
+     */
+    list(options?: ListEndUsersOptions): Promise<EndUserListResponse>;
+    /**
+     * Get an end-user by ID
+     */
+    get(userId: string): Promise<EndUser>;
+    /**
+     * Get an end-user by external ID
+     */
+    getByExternalId(externalId: string): Promise<EndUser>;
+    /**
+     * Create an end-user manually
+     */
+    create(data: CreateEndUserRequest): Promise<EndUser>;
+    /**
+     * Update an end-user profile
+     */
+    update(userId: string, data: UpdateEndUserRequest): Promise<EndUser>;
+    /**
+     * Delete an end-user
+     */
+    delete(userId: string): Promise<void>;
+    /**
+     * Link a wallet to an end-user
+     */
+    linkWallet(userId: string, request: LinkWalletRequest): Promise<EndUser>;
+    /**
+     * Unlink wallet from an end-user
+     */
+    unlinkWallet(userId: string): Promise<EndUser>;
+    /**
+     * Get user activity/events
+     */
+    getActivity(userId: string, options?: {
+        page?: number;
+        page_size?: number;
+        event_type?: string;
+    }): Promise<UserActivityResponse>;
+    /**
+     * Add points to a user
+     */
+    addPoints(userId: string, points: number, reason?: string): Promise<EndUser>;
+    /**
+     * Add a segment to a user
+     */
+    addSegment(userId: string, segment: string): Promise<EndUser>;
+    /**
+     * Remove a segment from a user
+     */
+    removeSegment(userId: string, segment: string): Promise<EndUser>;
+    /**
+     * Merge two users (moves all data from source to target)
+     */
+    merge(request: MergeUsersRequest): Promise<EndUser>;
+    /**
+     * Export users as CSV
+     */
+    export(options?: {
+        segment?: string;
+        format?: 'csv' | 'json';
+    }): Promise<Blob>;
+}
+
+/**
+ * Rewards API Client
+ *
+ * Manage reward definitions, earned rewards, and NFT minting.
+ */
+
+interface RewardDefinition {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    reward_type: 'nft' | 'points' | 'token' | 'badge';
+    value?: number;
+    value_currency?: string;
+    token_contract_address?: string;
+    token_symbol?: string;
+    token_decimals: number;
+    token_chain: string;
+    nft_minting_strategy?: string;
+    nft_pre_mint_count?: number;
+    nft_minted_pool_count: number;
+    nft_is_soulbound: boolean;
+    passport_threshold_id?: string;
+    trigger_type: string;
+    trigger_config?: Record<string, any>;
+    max_per_user?: number;
+    max_total?: number;
+    current_issued: number;
+    is_active: boolean;
+    icon_url?: string;
+    badge_color?: string;
+    created_at: string;
+}
+interface EarnedReward {
+    id: string;
+    user_id: string;
+    user_external_id: string;
+    reward_name: string;
+    reward_type: string;
+    status: string;
+    nft_token_id?: number;
+    nft_tx_hash?: string;
+    earned_at: string;
+    distributed_at?: string;
+}
+interface RewardAsset {
+    id: string;
+    definition_id: string;
+    asset_type: string;
+    file_path: string;
+    mime_type: string;
+    file_size: number;
+    metadata?: Record<string, any>;
+    created_at: string;
+}
+interface CreateRewardDefinitionRequest {
+    name: string;
+    slug: string;
+    description?: string;
+    campaign_id?: string;
+    reward_type?: 'nft' | 'points' | 'token' | 'badge';
+    value?: number;
+    value_currency?: string;
+    token_contract_address?: string;
+    token_symbol?: string;
+    token_decimals?: number;
+    token_chain?: string;
+    nft_metadata_template?: Record<string, any>;
+    nft_is_soulbound?: boolean;
+    nft_validity_days?: number;
+    nft_minting_strategy?: 'mint_on_earn' | 'pre_mint_pool' | 'lazy_mint';
+    nft_pre_mint_count?: number;
+    passport_threshold_id?: string;
+    trigger_type?: 'event_count' | 'event_match' | 'threshold' | 'manual' | 'custom_code';
+    trigger_config?: Record<string, any>;
+    max_per_user?: number;
+    max_total?: number;
+    is_active?: boolean;
+    icon_url?: string;
+    badge_color?: string;
+    is_public?: boolean;
+}
+interface ManualRewardRequest {
+    definition_id: string;
+    user_ids: string[];
+    trigger_data?: Record<string, any>;
+    distribute_immediately?: boolean;
+}
+interface ListRewardsOptions {
+    is_active?: boolean;
+    reward_type?: string;
+    limit?: number;
+    offset?: number;
+}
+declare class RewardsClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List reward definitions
+     */
+    listDefinitions(options?: ListRewardsOptions): Promise<RewardDefinition[]>;
+    /**
+     * Get a reward definition by ID
+     */
+    getDefinition(definitionId: string): Promise<RewardDefinition>;
+    /**
+     * Create a reward definition
+     */
+    createDefinition(data: CreateRewardDefinitionRequest): Promise<RewardDefinition>;
+    /**
+     * Update a reward definition
+     */
+    updateDefinition(definitionId: string, data: Partial<CreateRewardDefinitionRequest>): Promise<RewardDefinition>;
+    /**
+     * Delete a reward definition
+     */
+    deleteDefinition(definitionId: string): Promise<void>;
+    /**
+     * Activate a reward definition
+     */
+    activateDefinition(definitionId: string): Promise<RewardDefinition>;
+    /**
+     * Deactivate a reward definition
+     */
+    deactivateDefinition(definitionId: string): Promise<RewardDefinition>;
+    /**
+     * List earned rewards
+     */
+    listEarned(options?: {
+        user_id?: string;
+        definition_id?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<EarnedReward[]>;
+    /**
+     * Get earned rewards for a user
+     */
+    getUserRewards(userId: string): Promise<EarnedReward[]>;
+    /**
+     * Manually award rewards to users
+     */
+    awardManual(request: ManualRewardRequest): Promise<EarnedReward[]>;
+    /**
+     * Distribute pending rewards (mint NFTs, transfer tokens)
+     */
+    distributePending(earnedRewardId: string): Promise<EarnedReward>;
+    /**
+     * Upload an asset for a reward (image, metadata JSON)
+     */
+    uploadAsset(definitionId: string, file: Blob, assetType: 'image' | 'metadata' | 'animation'): Promise<RewardAsset>;
+    /**
+     * List assets for a reward definition
+     */
+    listAssets(definitionId: string): Promise<RewardAsset[]>;
+}
+
+/**
+ * Quests API Client
+ *
+ * Manage quests, steps, and user progress tracking.
+ */
+
+interface Quest {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    short_description?: string;
+    icon_url?: string;
+    banner_url?: string;
+    category?: string;
+    difficulty?: string;
+    estimated_time?: string;
+    is_ordered: boolean;
+    is_repeatable: boolean;
+    repeat_cooldown_hours?: number;
+    max_completions_per_user?: number;
+    starts_at?: string;
+    ends_at?: string;
+    time_limit_hours?: number;
+    prerequisite_quest_ids: string[];
+    max_participants?: number;
+    max_completions?: number;
+    reward_definition_id?: string;
+    reward_points?: number;
+    is_public: boolean;
+    is_featured: boolean;
+    tags: string[];
+    status: 'draft' | 'active' | 'paused' | 'completed' | 'archived';
+    steps: QuestStep[];
+    total_participants: number;
+    total_completions: number;
+    created_at: string;
+    updated_at: string;
+}
+interface QuestStep {
+    id: string;
+    quest_id: string;
+    name: string;
+    description?: string;
+    order: number;
+    step_type: 'event' | 'manual' | 'external' | 'compound';
+    event_type?: string;
+    event_types?: string[];
+    criteria?: Record<string, any>;
+    required_data_fields?: string[];
+    step_points?: number;
+    icon_url?: string;
+    is_optional: boolean;
+}
+interface UserQuestProgress {
+    id: string;
+    user_id: string;
+    quest_id: string;
+    quest_name: string;
+    status: 'not_started' | 'in_progress' | 'completed' | 'failed' | 'expired';
+    started_at?: string;
+    completed_at?: string;
+    expires_at?: string;
+    completion_count: number;
+    current_step_order: number;
+    step_progress: StepProgress[];
+    points_earned: number;
+    reward_earned: boolean;
+}
+interface StepProgress {
+    step_id: string;
+    step_name: string;
+    order: number;
+    status: 'pending' | 'in_progress' | 'completed' | 'skipped';
+    completed_at?: string;
+    event_id?: string;
+}
+interface QuestWithProgress extends Quest {
+    user_progress?: UserQuestProgress;
+}
+interface CreateQuestRequest {
+    name: string;
+    slug?: string;
+    description?: string;
+    short_description?: string;
+    icon_url?: string;
+    banner_url?: string;
+    category?: string;
+    difficulty?: string;
+    estimated_time?: string;
+    is_ordered?: boolean;
+    is_repeatable?: boolean;
+    repeat_cooldown_hours?: number;
+    max_completions_per_user?: number;
+    starts_at?: string;
+    ends_at?: string;
+    time_limit_hours?: number;
+    prerequisite_quest_ids?: string[];
+    max_participants?: number;
+    max_completions?: number;
+    reward_definition_id?: string;
+    reward_points?: number;
+    is_public?: boolean;
+    is_featured?: boolean;
+    tags?: string[];
+    steps: CreateQuestStepRequest[];
+}
+interface CreateQuestStepRequest {
+    name: string;
+    description?: string;
+    order?: number;
+    step_type?: 'event' | 'manual' | 'external' | 'compound';
+    event_type?: string;
+    event_types?: string[];
+    criteria?: Record<string, any>;
+    required_data_fields?: string[];
+    step_points?: number;
+    icon_url?: string;
+    is_optional?: boolean;
+}
+interface ListQuestsOptions {
+    status?: string;
+    category?: string;
+    is_public?: boolean;
+    is_featured?: boolean;
+    limit?: number;
+    offset?: number;
+}
+declare class QuestsClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List quests
+     */
+    list(options?: ListQuestsOptions): Promise<Quest[]>;
+    /**
+     * Get a quest by ID
+     */
+    get(questId: string): Promise<Quest>;
+    /**
+     * Get a quest by slug
+     */
+    getBySlug(slug: string): Promise<Quest>;
+    /**
+     * Create a quest
+     */
+    create(data: CreateQuestRequest): Promise<Quest>;
+    /**
+     * Update a quest
+     */
+    update(questId: string, data: Partial<CreateQuestRequest>): Promise<Quest>;
+    /**
+     * Delete a quest
+     */
+    delete(questId: string): Promise<void>;
+    /**
+     * Activate a quest
+     */
+    activate(questId: string): Promise<Quest>;
+    /**
+     * Pause a quest
+     */
+    pause(questId: string): Promise<Quest>;
+    /**
+     * Archive a quest
+     */
+    archive(questId: string): Promise<Quest>;
+    /**
+     * Get quest with user progress
+     */
+    getWithProgress(questId: string, userId: string): Promise<QuestWithProgress>;
+    /**
+     * List quests with progress for a user
+     */
+    listWithProgress(userId: string, options?: ListQuestsOptions): Promise<QuestWithProgress[]>;
+    /**
+     * Start a quest for a user
+     */
+    startQuest(questId: string, userId: string): Promise<UserQuestProgress>;
+    /**
+     * Get user's progress on a quest
+     */
+    getUserProgress(questId: string, userId: string): Promise<UserQuestProgress>;
+    /**
+     * Complete a step manually
+     */
+    completeStep(questId: string, userId: string, stepId: string): Promise<UserQuestProgress>;
+    /**
+     * Get all quest progress for a user
+     */
+    getAllUserProgress(userId: string): Promise<UserQuestProgress[]>;
+    /**
+     * Add a step to a quest
+     */
+    addStep(questId: string, step: CreateQuestStepRequest): Promise<QuestStep>;
+    /**
+     * Update a step
+     */
+    updateStep(questId: string, stepId: string, data: Partial<CreateQuestStepRequest>): Promise<QuestStep>;
+    /**
+     * Delete a step
+     */
+    deleteStep(questId: string, stepId: string): Promise<void>;
+    /**
+     * Reorder steps
+     */
+    reorderSteps(questId: string, stepIds: string[]): Promise<Quest>;
+}
+
+/**
+ * Schema Validation API Client
+ *
+ * Manage event schemas for data validation.
+ */
+
+interface Schema {
+    id: string;
+    name: string;
+    version: string;
+    display_name?: string;
+    description?: string;
+    status: 'draft' | 'active' | 'deprecated';
+    is_default: boolean;
+    usage_count: number;
+    created_at?: string;
+    updated_at?: string;
+}
+interface SchemaDetail extends Schema {
+    schema_definition: Record<string, any>;
+    yaml_content: string;
+}
+interface SchemaField {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    default?: any;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    values?: string[];
+}
+interface ValidationResult {
+    valid: boolean;
+    schema_name: string;
+    schema_version?: string;
+    errors: ValidationError$1[];
+}
+interface ValidationError$1 {
+    field: string;
+    message: string;
+    value?: any;
+}
+interface SchemaListResponse {
+    schemas: Schema[];
+    total: number;
+}
+interface CreateSchemaRequest {
+    yaml_content: string;
+}
+interface ValidateDataRequest {
+    schema_name: string;
+    schema_version?: string;
+    data: Record<string, any>;
+}
+interface ListSchemasOptions {
+    status?: 'draft' | 'active' | 'deprecated';
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+declare class SchemasClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List schemas
+     */
+    list(options?: ListSchemasOptions): Promise<SchemaListResponse>;
+    /**
+     * Get a schema by name and optional version
+     */
+    get(name: string, version?: string): Promise<SchemaDetail>;
+    /**
+     * Create a schema from YAML content
+     *
+     * Example YAML:
+     * ```yaml
+     * name: my_event
+     * version: "1.0"
+     * description: My custom event schema
+     *
+     * fields:
+     *   user_id:
+     *     type: string
+     *     required: true
+     *   amount:
+     *     type: number
+     *     min: 0
+     *   status:
+     *     type: enum
+     *     values: [pending, completed, failed]
+     * ```
+     */
+    create(yamlContent: string): Promise<SchemaDetail>;
+    /**
+     * Update a schema (creates new version)
+     */
+    update(name: string, yamlContent: string): Promise<SchemaDetail>;
+    /**
+     * Delete a schema
+     */
+    delete(name: string, version?: string): Promise<void>;
+    /**
+     * Activate a schema (make it available for validation)
+     */
+    activate(name: string, version?: string): Promise<Schema>;
+    /**
+     * Deprecate a schema
+     */
+    deprecate(name: string, version?: string): Promise<Schema>;
+    /**
+     * Set a schema as the default for its name
+     */
+    setDefault(name: string, version: string): Promise<Schema>;
+    /**
+     * Validate data against a schema
+     */
+    validate(request: ValidateDataRequest): Promise<ValidationResult>;
+    /**
+     * Validate data against multiple schemas
+     */
+    validateMultiple(schemaNames: string[], data: Record<string, any>): Promise<ValidationResult[]>;
+    /**
+     * Get schema usage statistics
+     */
+    getUsageStats(name: string): Promise<{
+        total_validations: number;
+        successful_validations: number;
+        failed_validations: number;
+        last_used_at?: string;
+    }>;
+    /**
+     * Clone a schema with a new name
+     */
+    clone(sourceName: string, newName: string, newVersion?: string): Promise<SchemaDetail>;
+}
+
+/**
+ * Data Views Client
+ *
+ * Client for managing and executing custom data views with multi-computation support.
+ */
+
+interface DataViewColumn {
+    name: string;
+    type: string;
+}
+interface DataViewInfo {
+    id: string;
+    name: string;
+    view_name: string;
+    description: string;
+    is_builtin: boolean;
+    columns: DataViewColumn[];
+}
+interface DataViewListResponse {
+    own_views: DataViewSummary[];
+    public_views: DataViewSummary[];
+    builtin_views: DataViewSummary[];
+}
+interface DataViewSummary {
+    name: string;
+    display_name?: string;
+    description: string;
+    view_type?: string;
+    source_categories?: string[];
+}
+interface DataViewDetail {
+    id: string;
+    name: string;
+    display_name: string;
+    description: string;
+    view_type: string;
+    computation: DataViewComputation | DataViewComputation[];
+    source_categories: string[];
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface DataViewComputation {
+    type: 'count' | 'score' | 'aggregate' | 'latest' | 'tier' | 'time_decay';
+    name?: string;
+    event_types?: string[];
+    time_window_days?: number;
+    event_weights?: Record<string, number>;
+    max_score?: number;
+    decay_rate?: number;
+    field?: string;
+    operation?: 'sum' | 'avg' | 'min' | 'max' | 'count';
+    group_by?: string;
+    limit?: number;
+    fields?: string[];
+    tiers?: TierDefinition[];
+    score_source?: string;
+}
+interface TierDefinition {
+    name: string;
+    min: number;
+    max: number;
+}
+interface DataViewExecuteResult {
+    view_name: string;
+    display_name: string;
+    identifier: string;
+    identifier_type: 'wallet' | 'user_id';
+    data: Record<string, unknown>;
+    computed_at: string;
+    total_events: number;
+}
+interface DataViewPreviewRequest {
+    wallet_address: string;
+    computation: DataViewComputation | DataViewComputation[];
+    time_window_days?: number;
+    limit?: number;
+}
+interface DataViewPreviewResult {
+    preview: true;
+    wallet_address: string;
+    computation_type: string;
+    result: Record<string, unknown>;
+    events_processed: number;
+    time_window_days: number;
+}
+interface CreateDataViewRequest {
+    name: string;
+    display_name: string;
+    description: string;
+    view_type?: string;
+    computation: DataViewComputation | DataViewComputation[];
+    source_categories?: string[];
+    is_public?: boolean;
+}
+interface UpdateDataViewRequest {
+    display_name?: string;
+    description?: string;
+    computation?: DataViewComputation | DataViewComputation[];
+    source_categories?: string[];
+    is_public?: boolean;
+}
+interface FanProfileView {
+    wallet_address: string;
+    fan_score: number;
+    total_events: number;
+    event_breakdown: Record<string, number>;
+    first_seen: string;
+    last_seen: string;
+    loyalty_tier: string;
+    computed_at: string;
+}
+interface ActivitySummaryView {
+    wallet_address: string;
+    total_events: number;
+    event_count_by_type: Record<string, number>;
+    last_activity: string;
+    active_days: number;
+    period_days: number;
+    computed_at: string;
+}
+interface EventMetadata {
+    event_types: Array<{
+        event_type: string;
+        count: number;
+        last_seen: string;
+    }>;
+    total_events: number;
+    categories: string[];
+}
+interface ViewTemplate {
+    id: string;
+    name: string;
+    description: string;
+    computation: DataViewComputation;
+}
+/**
+ * Data Views client for managing and executing custom data views.
+ *
+ * @example
+ * ```typescript
+ * const client = new ProofChain({ apiKey: 'your-api-key' });
+ *
+ * // List available views
+ * const views = await client.dataViews.list();
+ *
+ * // Execute a view for a wallet
+ * const result = await client.dataViews.execute('0x123...', 'fan_score');
+ *
+ * // Preview a computation
+ * const preview = await client.dataViews.preview({
+ *   wallet_address: '0x123...',
+ *   computation: {
+ *     type: 'score',
+ *     event_weights: { purchase: 10, login: 1 },
+ *     max_score: 1000
+ *   }
+ * });
+ * ```
+ */
+declare class DataViewsClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all available data views.
+     * Returns own views, public views from other tenants, and builtin views.
+     */
+    list(): Promise<DataViewListResponse>;
+    /**
+     * Get detailed information about a specific data view.
+     */
+    get(viewName: string): Promise<DataViewDetail>;
+    /**
+     * Create a new custom data view.
+     *
+     * @example
+     * ```typescript
+     * const view = await client.dataViews.create({
+     *   name: 'engagement_score',
+     *   display_name: 'User Engagement Score',
+     *   description: 'Weighted score based on user activity',
+     *   view_type: 'multi-computation',
+     *   computation: [
+     *     {
+     *       type: 'score',
+     *       name: 'activity_score',
+     *       event_types: ['page_view', 'purchase'],
+     *       event_weights: { page_view: 1, purchase: 10 },
+     *       max_score: 1000
+     *     },
+     *     {
+     *       type: 'tier',
+     *       name: 'loyalty_tier',
+     *       score_source: 'activity_score',
+     *       tiers: [
+     *         { name: 'Bronze', min: 0, max: 100 },
+     *         { name: 'Silver', min: 100, max: 500 },
+     *         { name: 'Gold', min: 500, max: 1000 }
+     *       ]
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    create(request: CreateDataViewRequest): Promise<DataViewDetail>;
+    /**
+     * Update an existing data view.
+     */
+    update(viewName: string, request: UpdateDataViewRequest): Promise<DataViewDetail>;
+    /**
+     * Delete a data view.
+     */
+    delete(viewName: string): Promise<void>;
+    /**
+     * Execute a data view for a specific user.
+     *
+     * The identifier can be either:
+     * - A wallet address (0x...) - queries web3-bound events
+     * - A user_id - queries all events for that user
+     *
+     * @example
+     * ```typescript
+     * // By user ID
+     * const result = await client.dataViews.execute('user-123', 'fan_score');
+     *
+     * // By wallet address
+     * const result = await client.dataViews.execute('0x123...abc', 'fan_score');
+     *
+     * console.log('Data:', result.data);
+     * console.log('Events processed:', result.total_events);
+     * ```
+     */
+    execute(identifier: string, viewName: string): Promise<DataViewExecuteResult>;
+    /**
+     * Preview a data view computation without saving it.
+     * Useful for testing computation configurations before creating a view.
+     *
+     * @example
+     * ```typescript
+     * const preview = await client.dataViews.preview({
+     *   wallet_address: '0x123...',
+     *   computation: {
+     *     type: 'score',
+     *     event_types: ['purchase', 'login'],
+     *     event_weights: { purchase: 10, login: 1 },
+     *     max_score: 1000
+     *   },
+     *   time_window_days: 30
+     * });
+     * ```
+     */
+    preview(request: DataViewPreviewRequest): Promise<DataViewPreviewResult>;
+    /**
+     * Get the fan profile view for a wallet.
+     * This is a builtin view that aggregates user activity into a profile.
+     */
+    getFanProfile(walletAddress: string): Promise<FanProfileView>;
+    /**
+     * Get the activity summary view for a wallet.
+     * This is a builtin view that summarizes user activity over time.
+     */
+    getActivitySummary(walletAddress: string, days?: number): Promise<ActivitySummaryView>;
+    /**
+     * Get event metadata including available event types and their counts.
+     * Useful for building dynamic UIs that show available event types.
+     */
+    getEventMetadata(): Promise<EventMetadata>;
+    /**
+     * Get available view templates for creating new views.
+     * Templates provide pre-configured computation patterns.
+     */
+    getTemplates(): Promise<ViewTemplate[]>;
+}
+
+/**
+ * ProofChain Client
+ */
+
+/**
+ * Documents resource for attestation operations.
+ */
+declare class DocumentsResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Attest a document file.
+     */
+    attest(request: AttestRequest): Promise<AttestationResult>;
+    /**
+     * Get a document by its IPFS hash.
+     */
+    get(ipfsHash: string): Promise<Event>;
+}
+/**
+ * Events resource for event operations.
+ */
+declare class EventsResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new attestation event.
+     */
+    create(request: CreateEventRequest): Promise<Event>;
+    /**
+     * Get an event by ID.
+     */
+    get(eventId: string): Promise<Event>;
+    /**
+     * List events with optional filters.
+     */
+    list(request?: ListEventsRequest): Promise<Event[]>;
+    /**
+     * Search events by query.
+     */
+    search(request: SearchRequest): Promise<SearchResult>;
+    /**
+     * Get an event by its IPFS hash.
+     */
+    byHash(ipfsHash: string): Promise<Event>;
+    /**
+     * Create multiple events in a batch.
+     *
+     * Note: For high-throughput ingestion, use the IngestionClient instead.
+     * This method is a convenience wrapper that creates events sequentially.
+     *
+     * @param events - Array of event requests
+     * @returns Array of created events
+     */
+    createBatch(events: CreateEventRequest[]): Promise<Event[]>;
+}
+/**
+ * Channels resource for state channel operations.
+ */
+declare class ChannelsResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new state channel.
+     */
+    create(request: CreateChannelRequest): Promise<Channel>;
+    /**
+     * Get a channel by ID.
+     */
+    get(channelId: string): Promise<Channel>;
+    /**
+     * Get detailed status of a channel.
+     */
+    status(channelId: string): Promise<ChannelStatus>;
+    /**
+     * List all channels.
+     */
+    list(limit?: number, offset?: number): Promise<Channel[]>;
+    /**
+     * Stream an event to a channel.
+     */
+    stream(channelId: string, request: StreamEventRequest): Promise<StreamAck>;
+    /**
+     * Stream multiple events in a single request.
+     */
+    streamBatch(channelId: string, events: StreamEventRequest[]): Promise<Record<string, unknown>>;
+    /**
+     * Settle a channel on-chain.
+     */
+    settle(channelId: string): Promise<Settlement>;
+    /**
+     * Close a channel.
+     */
+    close(channelId: string): Promise<Channel>;
+}
+/**
+ * Certificates resource for certificate operations.
+ */
+declare class CertificatesResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Issue a new certificate.
+     */
+    issue(request: IssueCertificateRequest): Promise<Certificate>;
+    /**
+     * Get a certificate by ID.
+     */
+    get(certificateId: string): Promise<Certificate>;
+    /**
+     * List certificates.
+     */
+    list(request?: ListCertificatesRequest): Promise<Certificate[]>;
+    /**
+     * Revoke a certificate.
+     */
+    revoke(certificateId: string, reason?: string): Promise<Certificate>;
+    /**
+     * Verify a certificate.
+     */
+    verify(certificateId: string): Promise<Record<string, unknown>>;
+}
+/**
+ * Webhooks resource for webhook operations.
+ */
+declare class WebhooksResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new webhook.
+     */
+    create(request: CreateWebhookRequest): Promise<Webhook>;
+    /**
+     * Get a webhook by ID.
+     */
+    get(webhookId: string): Promise<Webhook>;
+    /**
+     * List all webhooks.
+     */
+    list(): Promise<Webhook[]>;
+    /**
+     * Update a webhook.
+     */
+    update(webhookId: string, request: UpdateWebhookRequest): Promise<Webhook>;
+    /**
+     * Delete a webhook.
+     */
+    delete(webhookId: string): Promise<void>;
+    /**
+     * Send a test event to a webhook.
+     */
+    test(webhookId: string): Promise<Record<string, unknown>>;
+}
+/**
+ * Main ProofChain client.
+ */
+declare class ProofChain {
+    private http;
+    /** Documents resource for attestation operations */
+    documents: DocumentsResource;
+    /** Events resource for event operations */
+    events: EventsResource;
+    /** Channels resource for state channel operations */
+    channels: ChannelsResource;
+    /** Certificates resource for certificate operations */
+    certificates: CertificatesResource;
+    /** Webhooks resource for webhook operations */
+    webhooks: WebhooksResource;
+    /** Vault resource for file storage operations */
+    vault: VaultResource;
+    /** Search resource for advanced search operations */
+    search: SearchResource;
+    /** Verify resource for public verification operations */
+    verifyResource: VerifyResource;
+    /** Tenant resource for tenant management operations */
+    tenant: TenantResource;
+    /** Passport client for user passport operations */
+    passports: PassportClient;
+    /** Wallet client for CDP wallet operations */
+    wallets: WalletClient;
+    /** End users client for user management */
+    users: EndUsersClient;
+    /** Rewards client for reward definitions and distribution */
+    rewards: RewardsClient;
+    /** Quests client for quest management */
+    quests: QuestsClient;
+    /** Schemas client for event schema validation */
+    schemas: SchemasClient;
+    /** Data Views client for custom data view operations */
+    dataViews: DataViewsClient;
+    constructor(options: ProofChainOptions);
+    /**
+     * Create a client from environment variables.
+     * Reads PROOFCHAIN_API_KEY and optionally PROOFCHAIN_BASE_URL.
+     */
+    static fromEnv(): ProofChain;
+    /**
+     * Verify a document or event by its IPFS hash.
+     */
+    verify(ipfsHash: string): Promise<VerificationResult>;
+    /**
+     * Get information about the current tenant.
+     */
+    tenantInfo(): Promise<TenantInfo>;
+    /**
+     * Get API usage statistics.
+     */
+    usage(period?: string): Promise<UsageStats>;
+}
+
+/**
+ * High-Performance Ingestion Client
+ *
+ * Uses the Rust ingestion API at ingest.proofchain.co.za for maximum throughput.
+ * Supports single events, batch events, and WebSocket streaming.
+ */
+interface IngestEventRequest {
+    userId: string;
+    eventType: string;
+    data?: Record<string, unknown>;
+    eventSource?: string;
+    schemaIds?: string[];
+}
+interface IngestEventResponse {
+    eventId: string;
+    certificateId: string;
+    status: string;
+    queuePosition?: number;
+    estimatedConfirmation?: string;
+}
+interface BatchIngestRequest {
+    events: IngestEventRequest[];
+}
+interface BatchIngestResponse {
+    totalEvents: number;
+    queued: number;
+    failed: number;
+    results: IngestEventResponse[];
+}
+interface IngestionClientOptions {
+    apiKey: string;
+    ingestUrl?: string;
+    timeout?: number;
+}
+/**
+ * High-performance ingestion client for the Rust ingestion API.
+ *
+ * @example
+ * ```typescript
+ * const ingestion = new IngestionClient({ apiKey: 'your-api-key' });
+ *
+ * // Single event
+ * const result = await ingestion.ingest({
+ *   userId: 'user-123',
+ *   eventType: 'purchase',
+ *   data: { amount: 99.99, product: 'widget' }
+ * });
+ *
+ * // Batch events (up to 1000)
+ * const batchResult = await ingestion.ingestBatch({
+ *   events: [
+ *     { userId: 'user-1', eventType: 'click', data: { page: '/home' } },
+ *     { userId: 'user-2', eventType: 'click', data: { page: '/products' } },
+ *   ]
+ * });
+ * ```
+ */
+declare class IngestionClient {
+    private apiKey;
+    private ingestUrl;
+    private timeout;
+    constructor(options: IngestionClientOptions);
+    private getHeaders;
+    private handleResponse;
+    /**
+     * Ingest a single event using the high-performance Rust API.
+     * Events are attested immediately upon ingestion.
+     */
+    ingest(request: IngestEventRequest): Promise<IngestEventResponse>;
+    /**
+     * Ingest multiple events in a single request (up to 1000 events).
+     * More efficient than individual calls for bulk data.
+     */
+    ingestBatch(request: BatchIngestRequest): Promise<BatchIngestResponse>;
+    /**
+     * Get the status of an event by ID.
+     */
+    getEventStatus(eventId: string): Promise<{
+        status: string;
+        ipfsHash?: string;
+    }>;
+}
+
+/**
+ * ProofChain SDK Error Classes
+ */
+declare class ProofChainError extends Error {
+    statusCode?: number;
+    responseBody?: Record<string, unknown>;
+    constructor(message: string, statusCode?: number, responseBody?: Record<string, unknown>);
+}
+declare class AuthenticationError extends ProofChainError {
+    constructor(message?: string);
+}
+declare class AuthorizationError extends ProofChainError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends ProofChainError {
+    constructor(message?: string);
+}
+interface ValidationErrorDetail {
+    field: string;
+    message: string;
+}
+declare class ValidationError extends ProofChainError {
+    errors: ValidationErrorDetail[];
+    constructor(message?: string, errors?: ValidationErrorDetail[]);
+}
+declare class RateLimitError extends ProofChainError {
+    retryAfter?: number;
+    constructor(retryAfter?: number);
+}
+declare class ServerError extends ProofChainError {
+    constructor(message?: string, statusCode?: number);
+}
+declare class NetworkError extends ProofChainError {
+    cause?: Error;
+    constructor(message?: string, cause?: Error);
+}
+declare class TimeoutError extends ProofChainError {
+    constructor(message?: string);
+}
 
-export { AttestationClient, type AttestationClientConfig, AttestationClientError, AttestationRegistryContract, type AttestationRoot, type AuthResponse, type ChallengeRequest, type ChallengeResponse, type Event, type EventCreate, type EventQuery, type EventsListResponse, type HealthResponse, type LinkWalletRequest, type MerkleProof, type MerkleTree, type Quest, type QuestStep, type QuestStepCompletionResult, type QuestWithProgress, type RequestOptions, type RewardInfo, type RootHistory, type RootUpdatedEvent, type UserQuestProgress, type VerifyProofRequest, type VerifyProofResponse, type VerifyRequest, type Wallet, type WalletStatus, createClient };
+export { type Achievement, type ActivitySummaryView, type AddNFTRequest, type ApiKey, type AttestRequest, type AttestationMode, type AttestationResult, AuthenticationError, AuthorizationError, type AvailableView, type Badge, type BatchIngestRequest, type BatchIngestResponse, type BatchVerifyResult, type BlockchainProof, type BlockchainStats, type Certificate, type CertificateVerifyResult, CertificatesResource, type Channel, type ChannelState, type ChannelStatus, ChannelsResource, type ComprehensiveWalletInfo, type CreateAchievementRequest, type CreateApiKeyRequest, type CreateBadgeRequest, type CreateChannelRequest, type CreateDataViewRequest, type CreateDualWalletsRequest, type CreateEndUserRequest, type CreateEventRequest, type CreatePassportDefinitionRequest, type CreatePassportRequest, type CreateQuestRequest, type CreateQuestStepRequest, type CreateRewardDefinitionRequest, type CreateSchemaRequest, type CreateTemplateFieldRequest, type CreateTemplateRequest, type CreateWalletRequest, type CreateWebhookRequest, type DataViewColumn, type DataViewComputation, type DataViewDetail, type DataViewExecuteResult, type DataViewInfo, type DataViewListResponse, type DataViewPreviewRequest, type DataViewPreviewResult, type DataViewSummary, DataViewsClient, DocumentsResource, type DualWallets, type EarnedReward, type EndUser, type EndUserListResponse, EndUsersClient, type Event, type EventBatchProof, type EventMetadata, type EventStatus, EventsResource, type ExecuteSwapRequest, type Facet, type FacetsResponse, type FanProfileView, type FieldValue, type IngestEventRequest, type IngestEventResponse, IngestionClient, type IngestionClientOptions, type IssueCertificateRequest, type LinkWalletRequest, type ListCertificatesRequest, type ListEndUsersOptions, type ListEventsRequest, type ListQuestsOptions, type ListRewardsOptions, type ListSchemasOptions, type ManualRewardRequest, type MergeUsersRequest, type Milestone, type NFT, NetworkError, NotFoundError, type Passport, PassportClient, type PassportDefinition, type PassportFieldValue, type PassportHistory, type PassportTemplate, type PassportV2Data, type PassportWithFields, ProofChain, ProofChainError, type ProofChainOptions, type ProofVerifyResult, type Quest, type QuestStep, type QuestWithProgress, QuestsClient, RateLimitError, type RewardAsset, type RewardDefinition, RewardsClient, type Schema, type SchemaDetail, type SchemaField, type SchemaListResponse, type ValidationError$1 as SchemaValidationError, SchemasClient, type SearchFilters, type SearchQueryRequest, type SearchRequest, SearchResource, type SearchResponse, type SearchResult, type SearchStats, ServerError, type Settlement, type StepProgress, type StreamAck, type StreamEventRequest, type SwapQuote, type SwapQuoteRequest, type SwapResult, type TemplateField, type TenantInfo, TenantResource, type TierDefinition, TimeoutError, type TokenBalance, type TransferRequest, type TransferResult, type UpdateDataViewRequest, type UpdateEndUserRequest, type UpdatePassportRequest, type UpdateWebhookRequest, type UsageStats, type UserAchievement, type UserActivity, type UserActivityResponse, type UserBadge, type UserQuestProgress, type UserWalletSummary, type UserWithWallets, type UsersWithWalletsResponse, type ValidateDataRequest, ValidationError, type ValidationErrorDetail, type ValidationResult, type VaultFile, type VaultFolder, type VaultListResponse, VaultResource, type VaultStats, type VaultUploadRequest, type VerificationResult, VerifyResource, type ViewColumn, type ViewTemplate, type Wallet, type WalletBalance, WalletClient, type WalletStats, type Webhook, WebhooksResource };