@bind-protocol/sdk 0.7.0 → 0.9.0

package/dist/{client-BkohyCGJ.d.cts → client-CpJ87Xe0.d.ts}

@@ -1,5 +1,5 @@
 import { PublicPolicySpec } from '@bind-protocol/policy-spec';
-import { B as BindClientOptions, a as ProveJobInputs, V as VerificationMode, f as SubmitProveJobResponse, G as GetProveJobResponse, L as ListProveJobsOptions, g as ListProveJobsResponse, d as ProveJob, q as ListExtractorsResponse, r as ListAttestationsResponse, s as GetAttestationResponse, t as CreateSessionResponse, u as GetSessionResponse, p as ZkTlsSession, j as ListCircuitsResponse, k as GetCircuitResponse, A as ActivateCircuitResponse, w as ShareProofRequest, x as ShareProofResponse, y as ListSharedProofsOptions, z as ListSharedProofsResponse, D as GetSharedProofResponse, R as RevokeSharedProofResponse, J as VerifySharedProofResponse, H as VerifyJobStatusResponse, M as VerifyUploadedProofResponse, O as GetVerificationHistoryOptions, Q as GetVerificationHistoryResponse } from './types-Cz9q5U3r.cjs';
+import { B as BindClientOptions, c as ProveJobInputs, V as VerificationMode, S as SubmitProveJobResult, f as ProveJob, L as ListProveJobsOptions, g as ProveJobSummary, P as Pagination, a as PollOptions, k as ZkTlsExtractor, m as ZkTlsAttestation, n as ZkTlsSession, i as Circuit, A as ActivateCircuitResult, p as ShareProofRequest, o as SharedProof, q as ListSharedProofsOptions, R as RevokeSharedProofResult, s as VerificationResult, r as VerifyJobStatus, G as GetVerificationHistoryOptions, t as VerificationHistoryEntry } from './types-BcPssdQk.js';
 
 /**
  * BindClient - Main client for interacting with the Bind Protocol API
@@ -36,71 +36,85 @@ declare class BindClient {
          * - 'self_verify': Store in S3, client downloads and verifies locally
          */
         verificationMode?: VerificationMode;
-    }): Promise<SubmitProveJobResponse>;
+    }): Promise<SubmitProveJobResult>;
     /**
      * Get the status and results of a prove job
      * @param jobId - The unique job identifier
      * @returns The job details including status and outputs
+     * @throws {ApiError} If the API request fails
      */
-    getProveJob(jobId: string): Promise<GetProveJobResponse>;
+    getProveJob(jobId: string): Promise<ProveJob>;
     /**
      * List prove jobs for the authenticated organization
      * @param options - Optional filters for status, limit, and offset
      * @returns Paginated list of prove jobs
+     * @throws {ApiError} If the API request fails
      */
-    listProveJobs(options?: ListProveJobsOptions): Promise<ListProveJobsResponse>;
+    listProveJobs(options?: ListProveJobsOptions): Promise<{
+        jobs: ProveJobSummary[];
+        pagination: Pagination;
+    }>;
     /**
      * Poll for prove job completion
      * @param jobId - The unique job identifier
      * @param options - Polling options
      * @returns The completed or failed job
      * @throws {TimeoutError} If the job doesn't complete within the timeout
+     * @throws {ApiError} If the API request fails
      */
-    waitForProveJob(jobId: string, options?: {
-        intervalMs?: number;
-        timeoutMs?: number;
+    waitForProveJob(jobId: string, options?: PollOptions & {
         onProgress?: (job: ProveJob) => void;
     }): Promise<ProveJob>;
     /**
      * List all available public policies
      * @returns Array of public policy specifications
+     * @throws {ApiError} If the API request fails
      */
     listPolicies(): Promise<PublicPolicySpec[]>;
     /**
      * Get a specific policy by ID
      * @param policyId - The unique policy identifier
      * @returns The public policy specification, or null if not found
+     * @throws {ApiError} If the API request fails (except 404)
      */
     getPolicy(policyId: string): Promise<PublicPolicySpec | null>;
     /**
      * List available zkTLS extractors (data sources)
      * @returns Array of available extractors
+     * @throws {ApiError} If the API request fails
      */
-    listExtractors(): Promise<ListExtractorsResponse>;
+    listExtractors(): Promise<ZkTlsExtractor[]>;
     /**
      * List zkTLS attestations for the authenticated organization
      * @returns Array of attestations
+     * @throws {ApiError} If the API request fails
      */
-    listAttestations(): Promise<ListAttestationsResponse>;
+    listAttestations(): Promise<ZkTlsAttestation[]>;
     /**
      * Get a specific attestation by ID
      * @param attestationId - The attestation UUID
-     * @returns The attestation or null if not found
+     * @returns The attestation details
+     * @throws {ApiError} If the API request fails
      */
-    getAttestation(attestationId: string): Promise<GetAttestationResponse>;
+    getAttestation(attestationId: string): Promise<ZkTlsAttestation>;
     /**
      * Create a new zkTLS session for data attestation
      * @param extractorId - The extractor to use (e.g., "coinbase")
      * @param callbackUrl - URL to redirect to after authentication
      * @returns Session ID and auth URL to redirect user to
+     * @throws {ApiError} If the API request fails
      */
-    createZkTlsSession(extractorId: string, callbackUrl: string): Promise<CreateSessionResponse>;
+    createZkTlsSession(extractorId: string, callbackUrl: string): Promise<{
+        sessionId: string;
+        authUrl: string;
+    }>;
     /**
      * Get the status of a zkTLS session
      * @param sessionId - The session UUID
      * @returns Session status and attestation if completed
+     * @throws {ApiError} If the API request fails
      */
-    getZkTlsSession(sessionId: string): Promise<GetSessionResponse>;
+    getZkTlsSession(sessionId: string): Promise<ZkTlsSession>;
     /**
      * Wait for a zkTLS session to complete
      * @param sessionId - The session UUID
@@ -109,57 +123,66 @@ declare class BindClient {
      * @throws {ZkTlsSessionExpiredError} If session expires
      * @throws {ZkTlsSessionFailedError} If session fails
      * @throws {TimeoutError} If timeout is reached
+     * @throws {ApiError} If the API request fails
      */
-    waitForZkTlsSession(sessionId: string, options?: {
-        intervalMs?: number;
-        timeoutMs?: number;
+    waitForZkTlsSession(sessionId: string, options?: PollOptions & {
         onProgress?: (session: ZkTlsSession) => void;
     }): Promise<ZkTlsSession>;
     /**
      * List available circuits
      * @param options - Optional filters
      * @returns Array of circuits
+     * @throws {ApiError} If the API request fails
      */
     listCircuits(options?: {
         status?: 'active' | 'all';
         policyId?: string;
-    }): Promise<ListCircuitsResponse>;
+    }): Promise<Circuit[]>;
     /**
      * Get a specific circuit by ID
      * @param circuitId - The circuit identifier
-     * @returns The circuit details or null if not found
+     * @returns The circuit details
+     * @throws {ApiError} If the API request fails
      */
-    getCircuit(circuitId: string): Promise<GetCircuitResponse>;
+    getCircuit(circuitId: string): Promise<Circuit>;
     /**
      * Activate a circuit (requires validation to have passed)
      * @param circuitId - The circuit identifier to activate
      * @returns The activation result
+     * @throws {ApiError} If the API request fails
      */
-    activateCircuit(circuitId: string): Promise<ActivateCircuitResponse>;
+    activateCircuit(circuitId: string): Promise<ActivateCircuitResult>;
     /**
      * Share a completed proof with a verifier organization
      * @param request - Share proof request with proveJobId and verifierOrgId
      * @returns The created shared proof
+     * @throws {ApiError} If the API request fails
      */
-    shareProof(request: ShareProofRequest): Promise<ShareProofResponse>;
+    shareProof(request: ShareProofRequest): Promise<SharedProof>;
     /**
      * List shared proofs (outgoing or incoming)
      * @param options - Filter by direction, pagination, and inclusion options
      * @returns Paginated list of shared proofs
+     * @throws {ApiError} If the API request fails
      */
-    listSharedProofs(options?: ListSharedProofsOptions): Promise<ListSharedProofsResponse>;
+    listSharedProofs(options?: ListSharedProofsOptions): Promise<{
+        shares: SharedProof[];
+        pagination: Pagination;
+    }>;
     /**
      * Get a specific shared proof by ID
      * @param sharedProofId - The shared proof ID
      * @returns The shared proof details
+     * @throws {ApiError} If the API request fails
      */
-    getSharedProof(sharedProofId: string): Promise<GetSharedProofResponse>;
+    getSharedProof(sharedProofId: string): Promise<SharedProof>;
     /**
      * Revoke a shared proof. Only the sharing organization can revoke.
      * @param sharedProofId - The shared proof ID to revoke
      * @returns The revocation result
+     * @throws {ApiError} If the API request fails
      */
-    revokeSharedProof(sharedProofId: string): Promise<RevokeSharedProofResponse>;
+    revokeSharedProof(sharedProofId: string): Promise<RevokeSharedProofResult>;
     /**
      * Verify a shared proof
      *
@@ -169,31 +192,46 @@ declare class BindClient {
      * @param sharedProofId - The shared proof ID to verify
      * @param options - Optional polling configuration
      * @returns The verification result
+     * @throws {ApiError} If the API request fails
+     * @throws {TimeoutError} If verification doesn't complete within the timeout
      */
-    verifySharedProof(sharedProofId: string, options?: {
-        pollIntervalMs?: number;
-        maxWaitMs?: number;
-    }): Promise<VerifySharedProofResponse>;
+    verifySharedProof(sharedProofId: string, options?: PollOptions): Promise<VerificationResult>;
     /**
      * Get the status of a verification job
      * @param jobId - The verification job ID
-     * @returns The job status
+     * @returns The job status data
+     * @throws {ApiError} If the API request fails
      */
-    getVerifyJobStatus(jobId: string): Promise<VerifyJobStatusResponse>;
+    getVerifyJobStatus(jobId: string): Promise<{
+        status: VerifyJobStatus;
+        isValid?: boolean;
+        error?: string;
+        verificationTimeMs?: number;
+        creditsCharged: number;
+        verificationResultId?: string;
+        publicInputs?: string[];
+        publicInputsMatch?: boolean;
+    }>;
     /**
      * Verify an uploaded proof
      * @param proofBuffer - The proof binary as ArrayBuffer, Uint8Array, or Buffer
      * @param vkBuffer - The verification key binary as ArrayBuffer, Uint8Array, or Buffer
      * @returns The verification result
+     * @throws {ApiError} If the API request fails
      */
-    verifyUploadedProof(proofBuffer: ArrayBuffer | Uint8Array, vkBuffer: ArrayBuffer | Uint8Array): Promise<VerifyUploadedProofResponse>;
+    verifyUploadedProof(proofBuffer: ArrayBuffer | Uint8Array, vkBuffer: ArrayBuffer | Uint8Array): Promise<VerificationResult>;
     /**
      * Get verification history for the authenticated organization
      * @param options - Pagination options
      * @returns Paginated list of verification results
+     * @throws {ApiError} If the API request fails
      */
-    getVerificationHistory(options?: GetVerificationHistoryOptions): Promise<GetVerificationHistoryResponse>;
+    getVerificationHistory(options?: GetVerificationHistoryOptions): Promise<{
+        results: VerificationHistoryEntry[];
+        pagination: Pagination;
+    }>;
     private fetch;
+    private fetchJson;
     private sleep;
 }