@ghostspeak/sdk 2.0.6 → 2.0.7

package/dist/GhostSpeakClient-CWmGaM9Q.d.ts

@@ -0,0 +1,1007 @@
+import { TransactionSigner } from '@solana/kit';
+import { G as GovernanceProposal, V as VoteChoice } from './reputation-types-Yebf0Rm_.js';
+import { Address } from '@solana/addresses';
+import { W as W3CVerifiableCredential, B as BaseModule, G as GhostSpeakConfig, A as AgentModule, a as GovernanceModule, M as MultisigModule, P as PayAIClient, R as ReputationModule, D as DidModule, S as StakingModule } from './StakingModule-C5rzuOWb.js';
+import { CrossmintClientOptions } from './credentials.js';
+import { C as CreateAuthorizationParams, S as SigningKeypair, R as ReputationAuthorization, O as OnChainStorageConfig, A as AuthorizationStatus, k as AuthorizationWithStatus, l as AuthorizationFilter } from './signature-verification-DGxR4aYQ.js';
+
+/**
+ * Privacy mode for reputation display
+ *
+ * Determines how much reputation information is publicly visible.
+ */
+declare enum PrivacyMode {
+    /** Full disclosure - all reputation data is public */
+    Public = "Public",
+    /** Show only reputation tier (Bronze/Silver/Gold/Platinum) */
+    TierOnly = "TierOnly",
+    /** Show score range bucket (e.g., 750-850) */
+    RangeOnly = "RangeOnly",
+    /** Custom selective disclosure */
+    Custom = "Custom",
+    /** Fully confidential - ZK proofs required */
+    Confidential = "Confidential"
+}
+/**
+ * Visibility level for individual metrics
+ */
+declare enum VisibilityLevel {
+    /** Visible to everyone */
+    Public = "Public",
+    /** Visible only to authorized viewers */
+    Private = "Private",
+    /** Visible only with ZK proof */
+    ZKProof = "ZKProof"
+}
+/**
+ * Reputation tier levels (for tier-only privacy mode)
+ */
+declare enum ReputationTier {
+    None = "None",
+    Bronze = "Bronze",
+    Silver = "Silver",
+    Gold = "Gold",
+    Platinum = "Platinum"
+}
+/**
+ * Score range buckets (for range-only privacy mode)
+ */
+declare enum ScoreRange {
+    VeryLow = "VeryLow",// 0-2000
+    Low = "Low",// 2000-5000
+    Medium = "Medium",// 5000-7500
+    High = "High",// 7500-9000
+    VeryHigh = "VeryHigh"
+}
+/**
+ * Selective disclosure settings for individual metrics
+ */
+interface MetricVisibility {
+    /** Show exact Ghost Score */
+    showScore: VisibilityLevel;
+    /** Show total jobs completed */
+    showJobsCompleted: VisibilityLevel;
+    /** Show success rate percentage */
+    showSuccessRate: VisibilityLevel;
+    /** Show average response time */
+    showResponseTime: VisibilityLevel;
+    /** Show dispute statistics */
+    showDisputes: VisibilityLevel;
+    /** Show earnings/payment data */
+    showEarnings: VisibilityLevel;
+    /** Show client ratings */
+    showRatings: VisibilityLevel;
+    /** Show badges earned */
+    showBadges: VisibilityLevel;
+}
+/**
+ * Privacy settings for an agent's reputation
+ */
+interface PrivacySettings {
+    /** Agent public key */
+    agent: Address;
+    /** Current privacy mode */
+    mode: PrivacyMode;
+    /** Metric-specific visibility settings */
+    metricVisibility: MetricVisibility;
+    /** List of addresses with viewing permission */
+    authorizedViewers: Address[];
+    /** Auto-grant access to clients who pay */
+    autoGrantClients: boolean;
+    /** Last updated timestamp */
+    updatedAt: number;
+}
+/**
+ * Privacy preset configurations
+ */
+interface PrivacyPreset {
+    /** Preset name */
+    name: string;
+    /** Privacy mode */
+    mode: PrivacyMode;
+    /** Metric visibility settings */
+    metricVisibility: MetricVisibility;
+    /** Auto-grant to clients */
+    autoGrantClients: boolean;
+}
+/**
+ * Built-in privacy presets
+ */
+declare const PrivacyPresets: Record<string, PrivacyPreset>;
+/**
+ * Visible reputation data (filtered by privacy settings)
+ *
+ * This is the client-side type returned when fetching reputation
+ * with privacy filters applied.
+ */
+interface VisibleReputation {
+    /** Agent public key */
+    agent: Address;
+    /** Privacy mode applied */
+    privacyMode: PrivacyMode;
+    /** Exact score (only if visible) */
+    exactScore?: number;
+    /** Reputation tier (always visible in TierOnly mode) */
+    tier?: ReputationTier;
+    /** Score range (visible in RangeOnly mode) */
+    scoreRange?: ScoreRange;
+    /** Total jobs completed (if visible) */
+    totalJobsCompleted?: number;
+    /** Success rate percentage (if visible) */
+    successRate?: number;
+    /** Average response time in ms (if visible) */
+    avgResponseTime?: number;
+    /** Dispute statistics (if visible) */
+    disputes?: {
+        total: number;
+        resolved: number;
+    };
+    /** Total earnings (if visible) */
+    totalEarnings?: number;
+    /** Average rating (if visible) */
+    avgRating?: number;
+    /** Badges earned (if visible) */
+    badges?: string[];
+    /** Whether viewer has full access */
+    hasFullAccess: boolean;
+}
+/**
+ * Parameters for initializing privacy settings
+ */
+interface InitializePrivacyParams {
+    /** Agent address to enable privacy for */
+    agentAddress: Address;
+    /** Initial privacy mode */
+    mode?: PrivacyMode;
+    /** Metric visibility settings */
+    metricVisibility?: MetricVisibility;
+}
+/**
+ * Parameters for updating privacy mode
+ */
+interface UpdatePrivacyModeParams {
+    /** Agent address */
+    agentAddress: Address;
+    /** New privacy mode */
+    mode: PrivacyMode;
+}
+/**
+ * Parameters for setting metric visibility
+ */
+interface SetMetricVisibilityParams {
+    /** Agent address */
+    agentAddress: Address;
+    /** Metric visibility settings */
+    metricVisibility: MetricVisibility;
+}
+/**
+ * Parameters for granting viewer access
+ */
+interface GrantAccessParams {
+    /** Agent address */
+    agentAddress: Address;
+    /** Viewer address to grant access */
+    viewer: Address;
+}
+/**
+ * Parameters for revoking viewer access
+ */
+interface RevokeAccessParams {
+    /** Agent address */
+    agentAddress: Address;
+    /** Viewer address to revoke access */
+    viewer: Address;
+}
+/**
+ * Parameters for applying a privacy preset
+ */
+interface ApplyPresetParams {
+    /** Agent address */
+    agentAddress: Address;
+    /** Preset to apply */
+    preset: PrivacyPreset;
+}
+/**
+ * Privacy constants
+ */
+declare const PRIVACY_CONSTANTS: {
+    /** Score range thresholds */
+    SCORE_RANGES: {
+        VERY_LOW: {
+            min: number;
+            max: number;
+        };
+        LOW: {
+            min: number;
+            max: number;
+        };
+        MEDIUM: {
+            min: number;
+            max: number;
+        };
+        HIGH: {
+            min: number;
+            max: number;
+        };
+        VERY_HIGH: {
+            min: number;
+            max: number;
+        };
+    };
+    /** Tier thresholds */
+    TIER_THRESHOLDS: {
+        BRONZE: number;
+        SILVER: number;
+        GOLD: number;
+        PLATINUM: number;
+    };
+    /** Maximum authorized viewers */
+    MAX_AUTHORIZED_VIEWERS: number;
+};
+
+/**
+ * Unified Credential Service
+ *
+ * Bridges GhostSpeak's native Solana credentials with Crossmint's EVM-based VCs.
+ */
+
+interface UnifiedCredentialConfig {
+    programId?: Address;
+    crossmint?: CrossmintClientOptions;
+    crossmintTemplates?: {
+        agentIdentity?: string;
+        reputation?: string;
+        jobCompletion?: string;
+    };
+}
+interface IssuedCredentialResult {
+    solanaCredential: {
+        credentialId: string;
+    };
+    w3cCredential: W3CVerifiableCredential;
+    crossmintSync?: {
+        status: 'pending' | 'synced' | 'failed';
+        credentialId?: string;
+        chain?: string;
+        error?: string;
+    };
+}
+declare class UnifiedCredentialService {
+    private config;
+    private credentialModule;
+    private crossmintClient?;
+    constructor(config: UnifiedCredentialConfig);
+    /**
+     * Issue an Agent Identity credential.
+     * Note: logic simplified for SDK usage (mocking the on-chain part for now as per original implementation)
+     */
+    issueAgentIdentityCredential(params: {
+        agentId: string;
+        owner: string;
+        name: string;
+        capabilities: string[];
+        serviceEndpoint: string;
+        frameworkOrigin: string;
+        x402Enabled: boolean;
+        registeredAt: number;
+        verifiedAt: number;
+        recipientEmail?: string;
+        syncToCrossmint?: boolean;
+        signature: Uint8Array;
+    }): Promise<IssuedCredentialResult>;
+}
+
+/**
+ * Privacy module for managing reputation privacy settings
+ */
+declare class PrivacyModule extends BaseModule {
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Initialize privacy settings for an agent
+     *
+     * Sets up privacy controls for an agent's reputation data.
+     * By default, starts in Public mode with all metrics visible.
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Initialization parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await privacyModule.initializePrivacy(signer, {
+     *   agentAddress: agentPda,
+     *   mode: PrivacyMode.TierOnly,
+     *   metricVisibility: {
+     *     showScore: VisibilityLevel.Private,
+     *     showJobsCompleted: VisibilityLevel.Public,
+     *     // ... other metrics
+     *   }
+     * })
+     * ```
+     */
+    initializePrivacy(signer: TransactionSigner, params: InitializePrivacyParams): Promise<string>;
+    /**
+     * Update privacy mode for an agent
+     *
+     * Changes how reputation data is displayed publicly.
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Update parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * // Switch to tier-only mode
+     * await privacyModule.updatePrivacyMode(signer, {
+     *   agentAddress: agentPda,
+     *   mode: PrivacyMode.TierOnly
+     * })
+     * ```
+     */
+    updatePrivacyMode(signer: TransactionSigner, params: UpdatePrivacyModeParams): Promise<string>;
+    /**
+     * Set metric visibility settings
+     *
+     * Configure selective disclosure for individual metrics.
+     * Only works in Custom privacy mode.
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Metric visibility parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * await privacyModule.setMetricVisibility(signer, {
+     *   agentAddress: agentPda,
+     *   metricVisibility: {
+     *     showScore: VisibilityLevel.Private,
+     *     showJobsCompleted: VisibilityLevel.Public,
+     *     showSuccessRate: VisibilityLevel.Public,
+     *     showResponseTime: VisibilityLevel.Public,
+     *     showDisputes: VisibilityLevel.Private,
+     *     showEarnings: VisibilityLevel.Private,
+     *     showRatings: VisibilityLevel.Public,
+     *     showBadges: VisibilityLevel.Public
+     *   }
+     * })
+     * ```
+     */
+    setMetricVisibility(signer: TransactionSigner, params: SetMetricVisibilityParams): Promise<string>;
+    /**
+     * Grant viewer access to private reputation data
+     *
+     * Adds an address to the authorized viewers list, giving them
+     * full access to all private metrics.
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Grant access parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * // Grant access to a client
+     * await privacyModule.grantAccess(signer, {
+     *   agentAddress: agentPda,
+     *   viewer: clientAddress
+     * })
+     * ```
+     */
+    grantAccess(signer: TransactionSigner, params: GrantAccessParams): Promise<string>;
+    /**
+     * Revoke viewer access to private reputation data
+     *
+     * Removes an address from the authorized viewers list.
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Revoke access parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * // Revoke access from a viewer
+     * await privacyModule.revokeAccess(signer, {
+     *   agentAddress: agentPda,
+     *   viewer: viewerAddress
+     * })
+     * ```
+     */
+    revokeAccess(signer: TransactionSigner, params: RevokeAccessParams): Promise<string>;
+    /**
+     * Apply a privacy preset
+     *
+     * Quickly configure privacy settings using a predefined preset
+     * (Conservative, Balanced, or Open).
+     *
+     * @param signer - Transaction signer (must be agent owner)
+     * @param params - Preset parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * // Apply balanced preset
+     * await privacyModule.applyPreset(signer, {
+     *   agentAddress: agentPda,
+     *   preset: PrivacyPresets.BALANCED
+     * })
+     * ```
+     */
+    applyPreset(signer: TransactionSigner, params: ApplyPresetParams): Promise<string>;
+    /**
+     * Get privacy settings for an agent
+     *
+     * Fetches the current privacy configuration.
+     *
+     * @param agentAddress - Agent address
+     * @returns Privacy settings or null if not initialized
+     *
+     * @example
+     * ```typescript
+     * const settings = await privacyModule.getPrivacySettings(agentPda)
+     * if (settings) {
+     *   console.log('Privacy mode:', settings.mode)
+     *   console.log('Authorized viewers:', settings.authorizedViewers.length)
+     * }
+     * ```
+     */
+    getPrivacySettings(agentAddress: Address): Promise<PrivacySettings | null>;
+    /**
+     * Get visible reputation data (privacy-filtered)
+     *
+     * Fetches reputation data and applies privacy filters based on
+     * the viewer's access level.
+     *
+     * @param agentAddress - Agent address
+     * @param viewerAddress - Viewer address (for access check)
+     * @returns Privacy-filtered reputation data
+     *
+     * @example
+     * ```typescript
+     * // Get visible reputation for a specific viewer
+     * const visibleRep = await privacyModule.getVisibleReputation(
+     *   agentPda,
+     *   viewerAddress
+     * )
+     *
+     * console.log('Tier:', visibleRep.tier)
+     * console.log('Exact score:', visibleRep.exactScore) // Only if visible
+     * console.log('Has full access:', visibleRep.hasFullAccess)
+     * ```
+     */
+    getVisibleReputation(agentAddress: Address, viewerAddress: Address): Promise<VisibleReputation>;
+    /**
+     * Validate privacy settings before applying
+     *
+     * @param settings - Privacy settings to validate
+     * @returns Validation result
+     */
+    validateSettings(settings: PrivacySettings): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get available privacy presets
+     *
+     * @returns Record of available presets
+     */
+    getAvailablePresets(): Record<string, PrivacyPreset>;
+    /**
+     * Get default metric visibility for a privacy mode
+     *
+     * @param mode - Privacy mode
+     * @returns Default metric visibility
+     */
+    getDefaultVisibility(mode: PrivacyMode): MetricVisibility;
+    /**
+     * Calculate reputation tier from score
+     *
+     * @param score - Reputation score
+     * @returns Reputation tier
+     */
+    getTier(score: number): ReputationTier;
+    /**
+     * Calculate score range from score
+     *
+     * @param score - Reputation score
+     * @returns Score range
+     */
+    getRange(score: number): ScoreRange;
+    private derivePrivacyPda;
+}
+
+/**
+ * Authorization Module - Agent Pre-Authorization System
+ *
+ * GhostSpeak's trustless system for agents to pre-authorize facilitators
+ * (e.g., PayAI) to update their reputation with built-in security limits.
+ *
+ * @module AuthorizationModule
+ */
+
+/**
+ * Authorization Module
+ *
+ * Manages agent pre-authorizations for reputation updates.
+ */
+declare class AuthorizationModule extends BaseModule {
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Create a signed authorization for a facilitator
+     *
+     * @param params - Authorization parameters
+     * @param agentKeypair - Agent's keypair for signing
+     * @returns Signed authorization
+     *
+     * @example
+     * ```typescript
+     * const authorization = await client.authorization.createAuthorization({
+     *   authorizedSource: payAIFacilitatorAddress,
+     *   indexLimit: 1000, // Allow 1000 reputation updates
+     *   expiresIn: 30 * 24 * 60 * 60, // 30 days
+     *   network: 'devnet',
+     * }, agentKeypair)
+     * ```
+     */
+    createAuthorization(params: CreateAuthorizationParams, agentKeypair: SigningKeypair): Promise<ReputationAuthorization>;
+    /**
+     * Store authorization on-chain (optional, ~0.002 SOL fee)
+     *
+     * Creates a PDA account storing the authorization for on-chain verification.
+     * This provides an immutable audit trail but costs rent (~0.002 SOL).
+     *
+     * **Cost vs Benefit:**
+     * - Off-chain (default): Free, but requires sharing signed authorization
+     * - On-chain: ~0.002 SOL, provides transparent audit trail
+     *
+     * **When to use on-chain storage:**
+     * - High-value authorizations where transparency is critical
+     * - Compliance/audit requirements
+     * - Public agent reputation systems
+     *
+     * @param authorization - Authorization to store
+     * @param agentSigner - Agent's signer (or facilitator if they pay fee)
+     * @param config - Optional storage configuration
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * // Default: Agent pays ~0.002 SOL
+     * const sig = await client.authorization.storeAuthorizationOnChain(auth, agentSigner)
+     *
+     * // Custom fee structure
+     * const sig = await client.authorization.storeAuthorizationOnChain(auth, agentSigner, {
+     *   storageFee: 1500000n, // 0.0015 SOL
+     *   feePayedByAgent: false // Facilitator pays
+     * })
+     * ```
+     */
+    storeAuthorizationOnChain(authorization: ReputationAuthorization, agentSigner: TransactionSigner, config?: Partial<OnChainStorageConfig>): Promise<string>;
+    /**
+     * Verify authorization signature
+     *
+     * @param authorization - Authorization to verify
+     * @returns True if signature is valid
+     *
+     * @example
+     * ```typescript
+     * const isValid = await client.authorization.verifySignature(authorization)
+     * if (!isValid) {
+     *   throw new Error('Invalid authorization signature')
+     * }
+     * ```
+     */
+    verifySignature(authorization: ReputationAuthorization): Promise<boolean>;
+    /**
+     * Check authorization status (without on-chain call)
+     *
+     * @param authorization - Authorization to check
+     * @param currentIndex - Current usage count (optional, defaults to authorization.currentIndex)
+     * @returns Authorization status
+     */
+    getAuthorizationStatus(authorization: ReputationAuthorization, currentIndex?: number): {
+        status: AuthorizationStatus;
+        isValid: boolean;
+        remainingUses: number;
+        reason?: string;
+    };
+    /**
+     * Fetch authorization from on-chain PDA
+     *
+     * @param agentAddress - Agent's address
+     * @param authorizedSource - Authorized source address
+     * @param nonce - Optional nonce (must match creation)
+     * @returns Authorization with current on-chain status
+     */
+    fetchAuthorization(agentAddress: Address, authorizedSource: Address, nonce?: string): Promise<AuthorizationWithStatus | null>;
+    /**
+     * Update reputation using authorization
+     *
+     * Called by facilitators (e.g., PayAI) to update agent reputation
+     * using a pre-signed authorization.
+     *
+     * @param authorization - Authorization to use
+     * @param reputationChange - Reputation change to apply
+     * @param transactionSignature - Transaction signature for audit trail
+     * @param usageRecord - PDA for usage record (audit trail)
+     * @param metadata - Optional metadata
+     * @param facilitatorSigner - Facilitator's signer
+     * @returns Transaction signature
+     */
+    updateReputationWithAuth(authorization: ReputationAuthorization, reputationChange: number, transactionSignature: string, usageRecord: Address, metadata: Record<string, unknown> | undefined, facilitatorSigner: TransactionSigner): Promise<string>;
+    /**
+     * Revoke authorization
+     *
+     * Agent can revoke an authorization before it expires or is exhausted.
+     *
+     * @param agentAddress - Agent's address
+     * @param authorization - Authorization account PDA
+     * @param nonce - Optional nonce (must match creation)
+     * @param agentSigner - Agent's signer
+     * @returns Transaction signature
+     */
+    revokeAuthorization(agentAddress: Address, authorization: Address, nonce: string | undefined, agentSigner: TransactionSigner): Promise<string>;
+    /**
+     * List authorizations for an agent (filtering)
+     *
+     * @param filter - Filter criteria
+     * @returns List of authorizations
+     */
+    listAuthorizations(filter: AuthorizationFilter): Promise<AuthorizationWithStatus[]>;
+    /**
+     * Serialize authorization for storage/transmission
+     *
+     * @param authorization - Authorization to serialize
+     * @returns JSON-safe object
+     */
+    serializeAuthorization(authorization: ReputationAuthorization): Record<string, unknown>;
+    /**
+     * Deserialize authorization from storage/transmission
+     *
+     * @param data - Serialized authorization data
+     * @returns Authorization object
+     */
+    deserializeAuthorization(data: Record<string, unknown>): ReputationAuthorization;
+    /**
+     * Get authorization ID (deterministic hash)
+     *
+     * @param authorization - Authorization to hash
+     * @returns Base58-encoded hash
+     */
+    getAuthorizationId(authorization: ReputationAuthorization): Promise<string>;
+    /**
+     * Helper: Create authorization for PayAI facilitator
+     *
+     * Convenience method with sensible defaults for PayAI integration.
+     *
+     * @param payAIFacilitatorAddress - PayAI facilitator address
+     * @param agentKeypair - Agent's keypair
+     * @param options - Optional overrides
+     * @returns Signed authorization
+     *
+     * @example
+     * ```typescript
+     * const auth = await client.authorization.createPayAIAuthorization(
+     *   'PayAI...FacilitatorAddress',
+     *   agentKeypair,
+     *   { indexLimit: 5000 } // Optional overrides
+     * )
+     * ```
+     */
+    createPayAIAuthorization(payAIFacilitatorAddress: Address, agentKeypair: SigningKeypair, options?: Partial<CreateAuthorizationParams>): Promise<ReputationAuthorization>;
+    /**
+     * Calculate storage fee based on authorization duration and custom fees
+     *
+     * @param authorization - Authorization to calculate fee for
+     * @param config - Storage configuration
+     * @returns Fee in lamports
+     *
+     * @example
+     * ```typescript
+     * // Default fee: 0.002 SOL
+     * const fee = module.calculateStorageFee(auth)
+     *
+     * // Custom fee for 30-day authorizations: 0.001 SOL
+     * const fee = module.calculateStorageFee(auth, {
+     *   customFees: { 2592000: 1000000n } // 30 days = 0.001 SOL
+     * })
+     * ```
+     */
+    private calculateStorageFee;
+    /**
+     * Estimate on-chain storage cost for an authorization
+     *
+     * @param params - Authorization parameters
+     * @param config - Optional storage configuration
+     * @returns Estimated cost in SOL
+     *
+     * @example
+     * ```typescript
+     * const costInSOL = await client.authorization.estimateStorageCost({
+     *   authorizedSource: facilitatorAddress,
+     *   expiresIn: 30 * 24 * 60 * 60 // 30 days
+     * })
+     * console.log(`On-chain storage will cost ${costInSOL} SOL`)
+     * ```
+     */
+    estimateStorageCost(params: CreateAuthorizationParams, config?: Partial<OnChainStorageConfig>): Promise<number>;
+}
+
+/**
+ * Main GhostSpeak client with fluent API design
+ *
+ * Example usage:
+ * ```typescript
+ * const ghostspeak = new GhostSpeak()
+ *
+ * // Create an agent
+ * const agent = await ghostspeak
+ *   .agent()
+ *   .create({ name: "My Agent", capabilities: ["coding"] })
+ *   .compressed()
+ *   .execute()
+ *
+ * ```
+ */
+declare class GhostSpeakClient {
+    private config;
+    constructor(config?: Partial<GhostSpeakConfig>);
+    /**
+     * Direct access to Agent Module for read operations
+     */
+    get agents(): AgentModule;
+    /**
+     * Direct access to Governance Module for read operations
+     */
+    get governanceModule(): GovernanceModule;
+    /**
+     * Direct access to Multisig Module for read operations
+     */
+    get multisigModule(): MultisigModule;
+    /**
+     * Agent operations
+     */
+    agent(): AgentBuilder;
+    /**
+     * PayAI operations (x402 payments)
+     */
+    payai(): PayAIClient;
+    /**
+     * Reputation operations
+     */
+    reputation(): ReputationModule;
+    /**
+     * Reputation Tag Engine (Pillar 2: Granular Tags)
+     *
+     * Automatic tag assignment and management based on agent metrics.
+     * Features confidence scoring, evidence tracking, and tag decay.
+     */
+    tagEngine(): any;
+    /**
+     * Multi-Source Reputation Aggregator (Pillar 3: External Sources)
+     *
+     * Aggregate reputation data from multiple sources (PayAI, GitHub, custom webhooks)
+     * with weighted scoring and conflict detection.
+     */
+    reputationAggregator(): any;
+    /**
+     * Privacy operations
+     */
+    privacy(): PrivacyModule;
+    /**
+     * Governance operations
+     */
+    governance(): GovernanceBuilder;
+    /**
+     * Multisig operations
+     */
+    multisig(): MultisigBuilder;
+    /**
+     * Unified Credential operations (Solana + Crossmint)
+     */
+    credentials(): UnifiedCredentialService;
+    /**
+     * DID operations (Decentralized Identifiers)
+     */
+    did(): DidModule;
+    /**
+     * Direct access to Authorization Module for read operations
+     */
+    get authorization(): AuthorizationModule;
+    /**
+     * Direct access to Staking Module for read operations
+     */
+    get staking(): StakingModule;
+    /**
+     * Enable development mode features
+     */
+    enableDevMode(): this;
+    /**
+     * Configure network
+     */
+    useNetwork(cluster: 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet'): this;
+    /**
+     * Configure custom RPC
+     */
+    useRpc(endpoint: string, wsEndpoint?: string): this;
+    /**
+     * Get default RPC endpoint for cluster
+     */
+    private getDefaultRpcEndpoint;
+}
+/**
+ * Agent builder for fluent API
+ */
+declare class AgentBuilder {
+    private module;
+    private params;
+    constructor(config: GhostSpeakConfig);
+    create(params: {
+        name: string;
+        description?: string;
+        capabilities: string[];
+    }): this;
+    withDescription(description: string): this;
+    withType(agentType: number): this;
+    withIPFS(): this;
+    compressed(): this;
+    debug(): this;
+    withSigner(signer: TransactionSigner): this;
+    private validateParams;
+    getCost(): Promise<bigint>;
+    simulate(): Promise<unknown>;
+    explain(): Promise<string>;
+    execute(): Promise<{
+        address: Address;
+        signature: string;
+    }>;
+    private deriveAgentAddress;
+}
+/**
+ * Channel builder parameters interface
+ */
+/**
+ * Marketplace builder for fluent API
+ */
+/**
+ * Governance builder for fluent API
+ */
+declare class GovernanceBuilder {
+    private module;
+    private params;
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Create a governance proposal
+     */
+    proposal(): ProposalBuilder;
+    /**
+     * Get governance queries
+     */
+    query(): GovernanceQuery;
+    debug(): this;
+    withSigner(signer: TransactionSigner): this;
+}
+/**
+ * Governance builder parameters interface
+ */
+interface GovernanceBuilderParams {
+    signer?: TransactionSigner;
+}
+/**
+ * Proposal builder for fluent API
+ */
+declare class ProposalBuilder {
+    private module;
+    private builderParams;
+    private params;
+    constructor(module: GovernanceModule, builderParams: GovernanceBuilderParams);
+    create(params: {
+        title: string;
+        description: string;
+    }): this;
+    type(proposalType: 'parameter_change' | 'upgrade' | 'treasury'): this;
+    votingDuration(hours: number): this;
+    executionDelay(hours: number): this;
+    private validateParams;
+    execute(): Promise<{
+        address: Address;
+        signature: string;
+    }>;
+    withSigner(signer: TransactionSigner): this;
+}
+/**
+ * Governance query helper
+ */
+declare class GovernanceQuery {
+    private module;
+    constructor(module: GovernanceModule);
+    activeProposals(): Promise<{
+        address: Address;
+        data: GovernanceProposal;
+    }[]>;
+    proposalsByProposer(proposer: Address): Promise<{
+        address: Address;
+        data: GovernanceProposal;
+    }[]>;
+    proposalsByStatus(status: 'draft' | 'voting' | 'succeeded' | 'defeated' | 'executed'): Promise<{
+        address: Address;
+        data: GovernanceProposal;
+    }[]>;
+}
+/**
+ * Multisig builder for fluent API
+ */
+declare class MultisigBuilder {
+    private module;
+    private params;
+    constructor(config: GhostSpeakConfig);
+    create(): CreateMultisigBuilder;
+    proposal(): MultisigProposalBuilder;
+    approve(): MultisigApproveBuilder;
+    executeProposal(): MultisigExecuteBuilder;
+    withSigner(signer: TransactionSigner): this;
+    debug(): this;
+}
+interface MultisigBuilderParams {
+    signer?: TransactionSigner;
+}
+declare class CreateMultisigBuilder {
+    private module;
+    private builderParams;
+    private params;
+    constructor(module: MultisigModule, builderParams: MultisigBuilderParams);
+    withId(id: bigint): this;
+    threshold(t: number): this;
+    signers(s: Address[]): this;
+    execute(): Promise<{
+        signature: string;
+    }>;
+    withSigner(signer: TransactionSigner): this;
+}
+declare class MultisigProposalBuilder {
+    private module;
+    private builderParams;
+    private params;
+    constructor(module: MultisigModule, builderParams: MultisigBuilderParams);
+    forMultisig(address: Address): this;
+    title(t: string): this;
+    description(d: string): this;
+    execute(): Promise<{
+        signature: string;
+    }>;
+    withSigner(signer: TransactionSigner): this;
+}
+declare class MultisigApproveBuilder {
+    private module;
+    private builderParams;
+    private params;
+    constructor(module: MultisigModule, builderParams: MultisigBuilderParams);
+    proposal(address: Address): this;
+    vote(choice: VoteChoice): this;
+    reason(text: string): this;
+    tokenAccount(account: Address): this;
+    execute(): Promise<{
+        signature: string;
+    }>;
+    withSigner(signer: TransactionSigner): this;
+}
+declare class MultisigExecuteBuilder {
+    private module;
+    private builderParams;
+    private params;
+    constructor(module: MultisigModule, builderParams: MultisigBuilderParams);
+    proposal(address: Address): this;
+    target(programId: Address): this;
+    execute(): Promise<{
+        signature: string;
+    }>;
+    withSigner(signer: TransactionSigner): this;
+}
+/**
+ * Convert SOL to lamports
+ */
+declare function sol(amount: number): bigint;
+/**
+ * Convert lamports to SOL
+ */
+declare function lamportsToSol(lamports: bigint): number;
+
+export { AuthorizationModule as A, GhostSpeakClient as G, type InitializePrivacyParams as I, type MetricVisibility as M, PrivacyMode as P, ReputationTier as R, ScoreRange as S, type UpdatePrivacyModeParams as U, type VisibleReputation as V, type PrivacySettings as a, PrivacyModule as b, VisibilityLevel as c, PrivacyPresets as d, PRIVACY_CONSTANTS as e, type PrivacyPreset as f, type SetMetricVisibilityParams as g, type GrantAccessParams as h, type RevokeAccessParams as i, type ApplyPresetParams as j, UnifiedCredentialService as k, lamportsToSol as l, type UnifiedCredentialConfig as m, type IssuedCredentialResult as n, sol as s };