@ghostspeak/sdk 2.0.6 → 2.0.7

package/dist/StakingModule-C5rzuOWb.d.ts

@@ -0,0 +1,2526 @@
+import { Address as Address$1 } from '@solana/addresses';
+import { ReadonlyUint8Array, Address, Option, Decoder, FixedSizeDecoder, AccountMeta, Instruction, InstructionWithData, InstructionWithAccounts, WritableAccount, WritableSignerAccount, AccountSignerMeta, ReadonlyAccount, Commitment as Commitment$1, Rpc, GetLatestBlockhashApi, SendTransactionApi, GetAccountInfoApi, SimulateTransactionApi, GetFeeForMessageApi, GetProgramAccountsApi, GetEpochInfoApi, GetSignatureStatusesApi, GetMultipleAccountsApi, RpcSubscriptions, SignatureNotificationsApi, SlotNotificationsApi, AccountRole, TransactionSigner, Signature as Signature$1 } from '@solana/kit';
+import { I as IPFSConfig, G as GovernanceProposal, n as ProposalTypeArgs, E as ExecutionParamsArgs, o as CategoryReputation, B as BadgeType, J as JobPerformance, a as ReputationCalculationResult, p as ReputationTier, b as ReputationMetrics, c as TagScore, q as TagCategory, d as TagFilters, e as TagQueryResult } from './reputation-types-Yebf0Rm_.js';
+import { EventEmitter } from 'node:events';
+import { ParticipantType } from './types.js';
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/** Access tiers based on GHOST token stake amount */
+declare enum AccessTier {
+    None = 0,
+    Basic = 1,
+    Verified = 2,
+    Pro = 3,
+    Whale = 4
+}
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/**
+ * MultisigType defines the governance layer a multisig belongs to.
+ * Different types have different permissions and requirements.
+ */
+declare enum MultisigType {
+    Protocol = 0,
+    Dao = 1,
+    Dispute = 2,
+    AgentConsortium = 3,
+    AgentTreasury = 4,
+    Custom = 5
+}
+type MultisigTypeArgs = MultisigType;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type MultisigTypeConfigArgs = {
+    /** The multisig type */
+    multisigType: MultisigTypeArgs;
+    /** Required timelock duration in seconds (0 = no timelock) */
+    timelockSeconds: number | bigint;
+    /** Minimum number of signers allowed */
+    minSigners: number;
+    /** Maximum number of signers allowed */
+    maxSigners: number;
+    /** Minimum reputation score required (0-10000 basis points) */
+    minReputationScore: number;
+    /** Whether signers must hold governance tokens */
+    requiresTokenHoldings: boolean;
+    /** Minimum token balance required (if requires_token_holdings) */
+    minTokenBalance: number | bigint;
+};
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+declare enum PricingModel$1 {
+    Fixed = 0,
+    Hourly = 1,
+    PerTask = 2,
+    Subscription = 3,
+    Auction = 4,
+    Dynamic = 5,
+    RevenueShare = 6,
+    Tiered = 7
+}
+type PricingModelArgs = PricingModel$1;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type Agent = {
+    discriminator: ReadonlyUint8Array;
+    owner: Address;
+    agentId: string;
+    agentType: number;
+    name: string;
+    description: string;
+    capabilities: Array<string>;
+    pricingModel: PricingModel$1;
+    reputationScore: number;
+    totalJobsCompleted: number;
+    totalEarnings: bigint;
+    isActive: boolean;
+    createdAt: bigint;
+    updatedAt: bigint;
+    originalPrice: bigint;
+    genomeHash: string;
+    isReplicable: boolean;
+    replicationFee: bigint;
+    serviceEndpoint: string;
+    isVerified: boolean;
+    verificationTimestamp: bigint;
+    metadataUri: string;
+    frameworkOrigin: string;
+    supportedTokens: Array<Address>;
+    cnftMint: Option<Address>;
+    merkleTree: Option<Address>;
+    supportsA2a: boolean;
+    transferHook: Option<Address>;
+    parentAgent: Option<Address>;
+    generation: number;
+    x402Enabled: boolean;
+    x402PaymentAddress: Address;
+    x402AcceptedTokens: Array<Address>;
+    x402PricePerCall: bigint;
+    x402ServiceEndpoint: string;
+    x402TotalPayments: bigint;
+    x402TotalCalls: bigint;
+    lastPaymentTimestamp: bigint;
+    apiSpecUri: string;
+    apiVersion: string;
+    bump: number;
+};
+/** Gets the decoder for {@link Agent} account data. */
+declare function getAgentDecoder(): Decoder<Agent>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type StakingAccount = {
+    discriminator: ReadonlyUint8Array;
+    /** Owner of this staking account (can register multiple agents) */
+    owner: Address;
+    /** Amount of GHOST tokens staked */
+    amountStaked: bigint;
+    /** Timestamp when staking started */
+    stakedAt: bigint;
+    /** Lock duration in seconds (minimum 30 days) */
+    lockDuration: bigint;
+    /** Timestamp when unlock is available */
+    unlockAt: bigint;
+    /** Reputation boost percentage (in basis points, e.g., 500 = 5%) */
+    reputationBoostBps: number;
+    /** Whether agent has "Verified" badge */
+    hasVerifiedBadge: boolean;
+    /** Whether agent has premium listing benefits */
+    hasPremiumBenefits: boolean;
+    /** Total slashed amount (never recoverable) */
+    totalSlashed: bigint;
+    /** Current access tier based on stake amount */
+    tier: AccessTier;
+    /** Daily API calls remaining (resets every 24h) */
+    apiCallsRemaining: number;
+    /** Last API quota reset timestamp */
+    lastQuotaReset: bigint;
+    /** Voting power for governance (equals amount_staked) */
+    votingPower: bigint;
+    /** Bump for PDA */
+    bump: number;
+};
+/** Gets the decoder for {@link StakingAccount} account data. */
+declare function getStakingAccountDecoder(): FixedSizeDecoder<StakingAccount>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type StakingConfig = {
+    discriminator: ReadonlyUint8Array;
+    /** Authority who can update staking parameters */
+    authority: Address;
+    /** Minimum stake amount (1,000 GHOST) */
+    minStake: bigint;
+    /** Minimum lock duration (30 days in seconds) */
+    minLockDuration: bigint;
+    /** Slash percentage for fraud (50% = 5000 bps) */
+    fraudSlashBps: number;
+    /** Slash percentage for dispute loss (10% = 1000 bps) */
+    disputeSlashBps: number;
+    /** Treasury account for slashed tokens */
+    treasury: Address;
+    bump: number;
+};
+/** Gets the decoder for {@link StakingConfig} account data. */
+declare function getStakingConfigDecoder(): FixedSizeDecoder<StakingConfig>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+declare const GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS: Address<"4wHjA2a5YC4twZb4NQpwZpixo5FgxxzuJUrCG7UnF9pB">;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type InitializeGovernanceProposalInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountProposal extends string | AccountMeta<string> = string, TAccountProposer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountProposal extends string ? WritableAccount<TAccountProposal> : TAccountProposal,
+    TAccountProposer extends string ? WritableSignerAccount<TAccountProposer> & AccountSignerMeta<TAccountProposer> : TAccountProposer,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+
+/**
+ * PayAI Integration Types
+ *
+ * Type definitions for PayAI x402 facilitator integration,
+ * including webhook payloads and client configuration.
+ *
+ * @module payai/types
+ * @see https://docs.payai.network/x402/introduction
+ */
+
+/**
+ * PayAI webhook event types
+ */
+type PayAIWebhookEventType = 'payment.verified' | 'payment.settled' | 'payment.failed' | 'payment.refunded';
+/**
+ * PayAI payment status
+ */
+type PayAIPaymentStatus = 'pending' | 'verified' | 'settled' | 'failed' | 'refunded';
+/**
+ * PayAI supported networks
+ */
+type PayAINetwork = 'solana' | 'base' | 'ethereum' | 'polygon' | 'arbitrum';
+/**
+ * PayAI webhook payload for payment events
+ * This is sent to your webhook endpoint after payment verification/settlement
+ */
+interface PayAIWebhookPayload {
+    /** Unique event ID */
+    id: string;
+    /** Event type */
+    type: PayAIWebhookEventType;
+    /** Timestamp of the event (ISO 8601) */
+    timestamp: string;
+    /** Payment data */
+    data: PayAIPaymentData;
+}
+/**
+ * Payment data included in webhook payload
+ */
+interface PayAIPaymentData {
+    /** Unique payment ID from PayAI */
+    paymentId: string;
+    /** Transaction signature on-chain */
+    transactionSignature: string;
+    /** Blockchain network */
+    network: PayAINetwork;
+    /** Payer wallet address */
+    payer: string;
+    /** Merchant/Agent wallet address (payTo) */
+    merchant: string;
+    /** Payment amount in smallest unit (e.g., lamports for SOL, base units for USDC) */
+    amount: string;
+    /** Token/asset address */
+    asset: string;
+    /** Token symbol (e.g., 'USDC') */
+    assetSymbol: string;
+    /** Payment status */
+    status: PayAIPaymentStatus;
+    /** Resource URL that was paid for */
+    resource: string;
+    /** Response time in milliseconds (from request to response) */
+    responseTimeMs?: number;
+    /** HTTP status code of the resource response */
+    httpStatusCode?: number;
+    /** Whether the resource request was successful */
+    success?: boolean;
+    /** Timestamp when payment was verified */
+    verifiedAt?: string;
+    /** Timestamp when payment was settled */
+    settledAt?: string;
+    /** Additional metadata from the payment request */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Webhook verification result
+ */
+interface PayAIWebhookVerification {
+    valid: boolean;
+    error?: string;
+    payload?: PayAIWebhookPayload;
+}
+/**
+ * PayAI client configuration
+ */
+interface PayAIClientConfig {
+    /** PayAI facilitator URL (default: https://facilitator.payai.network) */
+    facilitatorUrl?: string;
+    /** Solana RPC endpoint */
+    rpcUrl: string;
+    /** User wallet for signing payments */
+    wallet?: {
+        publicKey: string;
+        signTransaction: (tx: unknown) => Promise<unknown>;
+    };
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Retry configuration */
+    retry?: {
+        attempts: number;
+        delayMs: number;
+    };
+}
+/**
+ * x402 payment requirement from a resource
+ */
+interface PayAIPaymentRequirement {
+    /** Payment scheme (e.g., 'exact') */
+    scheme: string;
+    /** Blockchain network */
+    network: PayAINetwork;
+    /** Maximum amount required in smallest unit */
+    maxAmountRequired: string;
+    /** Resource URL */
+    resource: string;
+    /** Description of the resource */
+    description?: string;
+    /** MIME type of the response */
+    mimeType?: string;
+    /** Recipient address */
+    payTo: string;
+    /** Token/asset address */
+    asset: string;
+    /** Maximum timeout in seconds */
+    maxTimeoutSeconds?: number;
+    /** Additional data */
+    extra?: Record<string, unknown>;
+}
+/**
+ * Payment response from PayAI facilitator
+ */
+interface PayAIPaymentResponse {
+    /** Whether payment was successful */
+    success: boolean;
+    /** Transaction signature */
+    transactionSignature?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Payment ID for tracking */
+    paymentId?: string;
+}
+/**
+ * Data to record for reputation tracking
+ * Extracted from PayAI webhook payloads
+ */
+interface PayAIReputationRecord {
+    /** Agent/Merchant address on Solana */
+    agentAddress: Address$1;
+    /** Payment signature for verification */
+    paymentSignature: string;
+    /** Payment amount */
+    amount: bigint;
+    /** Whether the service was successful */
+    success: boolean;
+    /** Response time in milliseconds */
+    responseTimeMs: number;
+    /** Payer address */
+    payerAddress: string;
+    /** Timestamp of payment */
+    timestamp: Date;
+    /** Network the payment was on */
+    network: PayAINetwork;
+}
+/**
+ * Agent registration data for PayAI marketplace sync
+ */
+interface PayAIAgentRegistration {
+    /** Agent's Solana address */
+    agentAddress: Address$1;
+    /** Service endpoint URL (x402-enabled) */
+    serviceEndpoint: string;
+    /** Agent capabilities/tags */
+    capabilities: string[];
+    /** Accepted payment tokens */
+    acceptedTokens: string[];
+    /** Pricing information */
+    pricing?: {
+        minPrice: string;
+        maxPrice: string;
+        currency: string;
+    };
+    /** Agent metadata */
+    metadata?: {
+        name?: string;
+        description?: string;
+        logo?: string;
+        website?: string;
+    };
+}
+/**
+ * Webhook handler options
+ */
+interface PayAIWebhookHandlerOptions {
+    /** Secret for verifying webhook signatures */
+    webhookSecret?: string;
+    /** Whether to verify webhook signatures (default: true in production) */
+    verifySignatures?: boolean;
+    /** Callback for handling verified payment events */
+    onPaymentVerified?: (data: PayAIPaymentData) => Promise<void>;
+    /** Callback for handling settled payment events */
+    onPaymentSettled?: (data: PayAIPaymentData) => Promise<void>;
+    /** Callback for handling failed payment events */
+    onPaymentFailed?: (data: PayAIPaymentData) => Promise<void>;
+    /** Callback for recording to reputation */
+    onRecordReputation?: (record: PayAIReputationRecord) => Promise<void>;
+}
+/**
+ * Webhook processing result
+ */
+interface PayAIWebhookResult {
+    /** Whether processing was successful */
+    success: boolean;
+    /** Event type that was processed */
+    eventType?: PayAIWebhookEventType;
+    /** Error message if failed */
+    error?: string;
+    /** Whether reputation was recorded */
+    reputationRecorded?: boolean;
+    /** Processed payment ID */
+    paymentId?: string;
+}
+
+/**
+ * CacheManager - Slot-aware RPC result caching
+ *
+ * Reduces RPC calls by caching account data and PDA derivations
+ * with commitment-level aware TTLs.
+ *
+ * @module CacheManager
+ */
+
+/**
+ * Cache configuration options
+ */
+interface CacheConfig {
+    /** Enable caching (default: false, opt-in) */
+    enabled?: boolean;
+    /** Maximum cache entries (default: 1000) */
+    maxSize?: number;
+    /** Custom TTL overrides (milliseconds) */
+    ttlOverrides?: {
+        processed?: number;
+        confirmed?: number;
+        finalized?: number;
+    };
+}
+/**
+ * CacheManager handles slot-aware caching for RPC results
+ *
+ * Features:
+ * - Commitment-level TTLs (finalized=30s, confirmed=2s, processed=500ms)
+ * - Indefinite PDA caching (deterministic addresses)
+ * - LRU eviction policy
+ * - Opt-in (disabled by default)
+ */
+declare class CacheManager {
+    private accountCache;
+    private pdaCache;
+    private config;
+    private ttls;
+    constructor(config?: CacheConfig);
+    /**
+     * Check if caching is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get cached account data
+     *
+     * @param address - Account address
+     * @param commitment - Commitment level
+     * @param currentSlot - Current blockchain slot (for staleness check)
+     * @returns Cached data or undefined
+     */
+    getAccount<T>(address: Address$1, commitment: Commitment$1, currentSlot?: number): T | undefined;
+    /**
+     * Cache account data
+     *
+     * @param address - Account address
+     * @param data - Account data to cache
+     * @param commitment - Commitment level
+     * @param slot - Blockchain slot when data was fetched
+     */
+    setAccount<T>(address: Address$1, data: T, commitment: Commitment$1, slot: number): void;
+    /**
+     * Get cached PDA
+     *
+     * PDAs are cached indefinitely as they're deterministic.
+     *
+     * @param seeds - Serialized seed components
+     * @returns Cached PDA or undefined
+     */
+    getPDA(seeds: string): Address$1 | undefined;
+    /**
+     * Cache PDA derivation
+     *
+     * @param seeds - Serialized seed components (use JSON.stringify for consistency)
+     * @param pda - Derived PDA address
+     */
+    setPDA(seeds: string, pda: Address$1): void;
+    /**
+     * Invalidate account cache entry
+     *
+     * @param address - Account address to invalidate
+     * @param commitment - Optional commitment level (invalidates all if not specified)
+     */
+    invalidateAccount(address: Address$1, commitment?: Commitment$1): void;
+    /**
+     * Clear all caches
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache size and hit/miss stats
+     */
+    getStats(): {
+        accountCache: {
+            size: number;
+            max: number;
+        };
+        pdaCache: {
+            size: number;
+            max: number;
+        };
+    };
+}
+
+type RpcApi = Rpc<GetLatestBlockhashApi & SendTransactionApi & GetAccountInfoApi & SimulateTransactionApi & GetFeeForMessageApi & GetProgramAccountsApi>;
+type ExtendedRpcApi = RpcApi & Rpc<GetEpochInfoApi & GetSignatureStatusesApi & GetMultipleAccountsApi>;
+type RpcSubscriptionApi = RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
+type Commitment = 'processed' | 'confirmed' | 'finalized';
+
+interface GhostSpeakConfig {
+    programId?: Address$1;
+    rpc: ExtendedRpcApi;
+    rpcSubscriptions?: RpcSubscriptionApi;
+    commitment?: Commitment;
+    transactionTimeout?: number;
+    defaultFeePayer?: Address$1;
+    retryConfig?: RetryConfig;
+    cluster?: 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+    rpcEndpoint?: string;
+    wsEndpoint?: string;
+    /** Optional logger for debug output */
+    logger?: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+    /** Cache configuration for RPC result caching */
+    cache?: CacheConfig;
+    /** Token 2022 configuration options */
+    token2022?: Token2022Config;
+    /** IPFS configuration for large content storage */
+    ipfsConfig?: IPFSConfig;
+    /** Credential configuration for Crossmint sync */
+    credentials?: CredentialConfig;
+    /** PayAI configuration */
+    payai?: Partial<PayAIClientConfig>;
+}
+interface CredentialConfig {
+    crossmintApiKey?: string;
+    crossmintEnvironment?: 'staging' | 'production';
+    crossmintChain?: 'base-sepolia' | 'polygon-amoy' | 'base' | 'polygon';
+    templates?: {
+        agentIdentity?: string;
+        reputation?: string;
+        jobCompletion?: string;
+    };
+}
+interface Token2022Config {
+    /** Enable Token 2022 features by default */
+    enabled?: boolean;
+    /** Default behavior for transfer fees */
+    defaultExpectTransferFees?: boolean;
+    /** Maximum transfer fee slippage (basis points) */
+    maxFeeSlippageBasisPoints?: number;
+    /** Enable confidential transfers by default */
+    enableConfidentialTransfers?: boolean;
+    /** Default Token 2022 program address (for custom deployments) */
+    programAddress?: Address$1;
+    /** Cache token program detection results for this many seconds */
+    tokenProgramCacheTtl?: number;
+}
+interface RetryConfig {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    retryableErrors?: string[];
+}
+interface AgentWithAddress {
+    address: Address$1;
+    data: Agent;
+}
+interface AgentRegistrationData {
+    agentId: string;
+    name: string;
+    description: string;
+    metadataUri: string;
+    agentType: number;
+}
+interface AgentAccount {
+    owner: Address$1;
+    name: string;
+    description: string;
+    capabilities: string[];
+    metadataUri: string;
+    serviceEndpoint: string;
+    isActive: boolean;
+    registeredAt: bigint;
+    reputation: number;
+    totalEarnings: bigint;
+    totalJobs: number;
+    successRate: number;
+    bump: number;
+}
+declare enum PricingModel {
+    Fixed = "Fixed",
+    Hourly = "Hourly",
+    PerTask = "PerTask",
+    Subscription = "Subscription",
+    Auction = "Auction"
+}
+declare class GhostSpeakError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+interface RegisterAgentParams {
+    agentData: AgentRegistrationData;
+}
+interface RpcResponse<T> {
+    value: T | null;
+}
+interface RpcAccountInfo {
+    executable: boolean;
+    lamports: bigint;
+    owner: Address$1;
+    rentEpoch: bigint;
+    space: bigint;
+    data: string | Uint8Array;
+}
+interface RpcProgramAccount {
+    pubkey: Address$1;
+    account: RpcAccountInfo;
+}
+interface RpcProgramAccountsResponse {
+    value: RpcProgramAccount[] | null;
+}
+interface RpcAccountInfoResponse {
+    value: RpcAccountInfo | null;
+}
+interface RpcMultipleAccountsResponse {
+    value: (RpcAccountInfo | null)[];
+}
+interface TransactionResponse {
+    signature: string;
+    confirmationStatus?: Commitment;
+    err?: unknown | null;
+}
+interface SimulatedTransactionResponse {
+    value: {
+        err?: unknown | null;
+        logs?: string[];
+        unitsConsumed?: number;
+    };
+}
+interface SolanaRpcClient {
+    getAccountInfo(address: Address$1, options?: {
+        commitment?: Commitment;
+        encoding?: string;
+    }): Promise<RpcAccountInfoResponse>;
+    getMultipleAccounts(addresses: Address$1[], options?: {
+        commitment?: Commitment;
+        encoding?: string;
+    }): Promise<RpcMultipleAccountsResponse>;
+    getProgramAccounts(programId: Address$1, options?: {
+        commitment?: Commitment;
+        encoding?: string;
+        filters?: unknown[];
+    }): Promise<RpcProgramAccountsResponse>;
+    sendTransaction(transaction: unknown, options?: {
+        commitment?: Commitment;
+    }): Promise<TransactionResponse>;
+    simulateTransaction(transaction: unknown, options?: {
+        commitment?: Commitment;
+    }): Promise<SimulatedTransactionResponse>;
+}
+interface EmergencyConfig {
+    emergencyDelay?: bigint;
+    emergencyThreshold?: number;
+    emergencySigners?: Address$1[];
+    canEmergencyPause?: boolean;
+    emergencyContact?: string;
+}
+
+/**
+ * Developer Tools for GhostSpeak SDK
+ *
+ * Provides debugging, inspection, and development utilities
+ */
+
+/**
+ * Transaction analysis result
+ */
+interface TransactionAnalysis {
+    instructions: InstructionAnalysis[];
+    totalAccounts: number;
+    signerCount: number;
+    writableAccounts: Address$1[];
+    readonlyAccounts: Address$1[];
+    estimatedSize: number;
+    estimatedComputeUnits: bigint;
+    estimatedFee: bigint;
+    warnings: string[];
+}
+/**
+ * Individual instruction analysis
+ */
+interface InstructionAnalysis {
+    index: number;
+    programId: Address$1;
+    accountCount: number;
+    dataSize: number;
+    humanReadable: string;
+    accounts: AccountInfo[];
+}
+/**
+ * Account information in instruction
+ */
+interface AccountInfo {
+    address: Address$1;
+    isWritable: boolean;
+    isSigner: boolean;
+    role: AccountRole;
+}
+
+/**
+ * Type for instruction-like objects from generated code
+ */
+type InstructionLike = {
+    programAddress: Address$1;
+    accounts?: readonly unknown[];
+    data?: unknown;
+};
+/**
+ * Unified instruction builder that eliminates duplication across all instruction classes.
+ * This is the single source of truth for instruction execution patterns.
+ */
+declare class InstructionBuilder {
+    private rpcClient;
+    private config;
+    private devTools;
+    private debugMode;
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Execute a single instruction with unified error handling and transaction patterns
+     */
+    execute<T = string>(instructionName: string, instructionGetter: () => Promise<InstructionLike> | InstructionLike, signers: TransactionSigner[], options?: {
+        simulate?: boolean;
+        returnDetails?: boolean;
+        skipPreflight?: boolean;
+        maxRetries?: number;
+    }): Promise<T>;
+    /**
+     * Execute multiple instructions in a single transaction
+     */
+    executeBatch<T = string>(batchName: string, instructionGetters: (() => Promise<InstructionLike> | InstructionLike)[], signers: TransactionSigner[], options?: {
+        simulate?: boolean;
+        returnDetails?: boolean;
+        skipPreflight?: boolean;
+    }): Promise<T>;
+    /**
+     * Get and decode account data with unified error handling
+     */
+    getAccount<T>(address: Address$1, decoderImportName: string): Promise<T | null>;
+    /**
+     * Get multiple accounts with unified pattern
+     */
+    getAccounts<T>(addresses: Address$1[], decoderImportName: string): Promise<(T | null)[]>;
+    /**
+     * Get program accounts with filters
+     */
+    getProgramAccounts<T>(decoderImportName: string, filters?: ({
+        dataSize: bigint;
+    } | {
+        memcmp: {
+            offset: bigint;
+            bytes: string;
+            encoding?: 'base58' | 'base64';
+        };
+    })[]): Promise<{
+        address: Address$1;
+        data: T;
+    }[]>;
+    /**
+     * Enable debug mode for next transaction
+     */
+    enableDebug(): this;
+    /**
+     * Debug transaction - analyze without executing
+     */
+    debug(instructionName: string, instructionGetters: (() => Promise<InstructionLike> | InstructionLike)[]): Promise<TransactionAnalysis>;
+    /**
+     * Get human-readable explanation of transaction
+     */
+    explain(instructionName: string, instructionGetters: (() => Promise<InstructionLike> | InstructionLike)[]): Promise<string>;
+    /**
+     * Estimate transaction cost
+     */
+    estimateCost(instructionGetters: (() => Promise<InstructionLike> | InstructionLike)[]): Promise<bigint>;
+    private sendAndConfirm;
+    private simulateInstruction;
+    private simulateBatch;
+    private estimateTransactionSize;
+    private extractRawData;
+    /**
+     * Create a communication session instruction
+     */
+    createCommunicationSession(_params: {
+        sessionId: bigint;
+        initiator: Address$1;
+        initiatorType: ParticipantType;
+        responder: Address$1;
+        responderType: ParticipantType;
+        sessionType: string;
+        metadata: string;
+        expiresAt: bigint;
+    }): Promise<InstructionLike>;
+    /**
+     * Send a communication message instruction
+     */
+    sendCommunicationMessage(_sessionAddress: Address$1, _params: {
+        messageId: bigint;
+        senderType: unknown;
+        content: string;
+        messageType: string;
+        attachments: string[];
+    }): Promise<InstructionLike>;
+    /**
+     * Update participant status instruction
+     */
+    updateParticipantStatus(_params: {
+        participant: Address$1;
+        participantType: unknown;
+        servicesOffered: string[];
+        availability: boolean;
+        reputationScore: number;
+    }): Promise<InstructionLike>;
+}
+
+/**
+ * Solana cluster types for URL generation
+ */
+type SolanaCluster = 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+/**
+ * Transaction result with verification URLs
+ */
+interface TransactionResult {
+    signature: string | Signature$1;
+    cluster: SolanaCluster;
+    urls: {
+        solanaExplorer: string;
+        solscan: string;
+        solanaFM: string;
+        xray: string;
+    };
+    commitment: Commitment;
+    timestamp: number;
+}
+
+type Signature = string;
+type IInstruction = Instruction;
+
+/**
+ * Base class for all instruction modules using the unified InstructionBuilder.
+ * This replaces the old BaseInstructions class with a much simpler pattern.
+ */
+declare abstract class BaseModule {
+    protected builder: InstructionBuilder;
+    protected config: GhostSpeakConfig;
+    protected logger?: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+    protected cacheManager: CacheManager;
+    private _debugMode;
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Enable debug mode for next operation
+     */
+    debug(): this;
+    /**
+     * Execute a single instruction
+     */
+    protected execute(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction, signers: TransactionSigner[]): Promise<string>;
+    /**
+     * Execute a single instruction with detailed result
+     */
+    protected executeWithDetails(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction, signers: TransactionSigner[]): Promise<TransactionResult>;
+    /**
+     * Execute multiple instructions in a batch
+     */
+    protected executeBatch(batchName: string, instructionGetters: (() => Promise<IInstruction> | IInstruction)[], signers: TransactionSigner[]): Promise<Signature>;
+    /**
+     * Simulate an instruction
+     */
+    protected simulate(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction, signers: TransactionSigner[]): Promise<unknown>;
+    /**
+     * Simulate an instruction (public accessor)
+     */
+    simulateInstruction(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction, signers: TransactionSigner[]): Promise<unknown>;
+    /**
+     * Estimate transaction cost
+     */
+    protected estimateCost(instructionGetters: (() => Promise<IInstruction> | IInstruction)[]): Promise<bigint>;
+    /**
+     * Get cost estimation for an instruction
+     */
+    getCost(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction): Promise<bigint>;
+    /**
+     * Get human-readable explanation
+     */
+    explain(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction): Promise<string>;
+    /**
+     * Debug analyze without executing
+     */
+    analyze(instructionName: string, instructionGetter: () => Promise<IInstruction> | IInstruction): Promise<unknown>;
+    /**
+     * Get decoded account (with optional caching)
+     */
+    protected getAccount<T>(address: Address$1, decoderImportName: string): Promise<T | null>;
+    /**
+     * Get multiple decoded accounts (with optional caching)
+     */
+    protected getAccounts<T>(addresses: Address$1[], decoderImportName: string): Promise<(T | null)[]>;
+    /**
+     * Get program accounts
+     */
+    protected getProgramAccounts<T>(decoderImportName: string, filters?: ({
+        dataSize: bigint;
+    } | {
+        memcmp: {
+            offset: bigint;
+            bytes: string;
+            encoding?: 'base58' | 'base64';
+        };
+    })[]): Promise<{
+        address: Address$1;
+        data: T;
+    }[]>;
+    /**
+     * Get program ID
+     */
+    protected get programId(): Address$1;
+    /**
+     * Get program ID (public accessor)
+     */
+    getProgramId(): Address$1;
+    /**
+     * Get commitment level
+     */
+    protected get commitment(): Commitment;
+    /**
+     * Get commitment level (public accessor)
+     */
+    getCommitment(): Commitment;
+    /**
+     * Invalidate cache for specific account
+     */
+    invalidateCache(address: Address$1): void;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        accountCache: {
+            size: number;
+            max: number;
+        };
+        pdaCache: {
+            size: number;
+            max: number;
+        };
+    };
+}
+
+/**
+ * Simplified agent management using unified instruction pattern
+ */
+declare class AgentModule extends BaseModule {
+    private ipfsUtils;
+    constructor(config: GhostSpeakConfig & {
+        ipfsConfig?: IPFSConfig;
+    });
+    /**
+     * Register a new agent
+     */
+    register(signer: TransactionSigner, params: {
+        agentType: number;
+        name: string;
+        description: string;
+        metadataUri: string;
+        agentId: string;
+        pricingModel?: PricingModel$1;
+        skipSimulation?: boolean;
+    }): Promise<string>;
+    /**
+     * Register a compressed agent (5000x cheaper)
+     */
+    registerCompressed(signer: TransactionSigner, params: {
+        agentType: number;
+        name: string;
+        description: string;
+        metadataUri: string;
+        agentId: string;
+        merkleTree: Address$1;
+        treeConfig?: Address$1;
+        pricingModel?: PricingModel$1;
+    }): Promise<string>;
+    /**
+     * Update agent metadata
+     */
+    update(signer: TransactionSigner, params: {
+        agentAddress: Address$1;
+        metadataUri: string;
+        agentType: number;
+        agentId: string;
+        name?: string | null;
+        description?: string | null;
+        pricingModel?: PricingModel$1;
+    }): Promise<string>;
+    /**
+     * Verify an agent
+     */
+    verify(signer: TransactionSigner, params: {
+        agentAddress: Address$1;
+        agentPubkey: Address$1;
+        serviceEndpoint: string;
+        supportedCapabilities: Array<number | bigint>;
+        verifiedAt: number | bigint;
+    }): Promise<string>;
+    /**
+     * Deactivate an agent
+     */
+    deactivate(signer: TransactionSigner, params: {
+        agentAddress: Address$1;
+        agentId: string;
+    }): Promise<string>;
+    /**
+     * Activate an agent
+     */
+    activate(signer: TransactionSigner, params: {
+        agentAddress: Address$1;
+        agentId: string;
+    }): Promise<string>;
+    /**
+     * Get agent account
+     */
+    getAgentAccount(address: Address$1): Promise<Agent | null>;
+    /**
+     * Get all agents
+     */
+    getAllAgents(): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Get agents by type
+     */
+    getAgentsByType(agentType: number): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Get user's agents
+     */
+    getUserAgents(authority: Address$1): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Batch get multiple agent accounts
+     *
+     * Uses efficient batching (100 accounts per RPC call) with optional caching.
+     *
+     * @param addresses - Agent addresses to fetch
+     * @param onProgress - Optional progress callback
+     * @returns Array of agent accounts (null for non-existent)
+     *
+     * @example
+     * ```typescript
+     * const agents = await client.agents.batchGetAgents(
+     *   ['agent1...', 'agent2...', 'agent3...'],
+     *   (completed, total) => console.log(`${completed}/${total}`)
+     * )
+     * ```
+     */
+    batchGetAgents(addresses: Address$1[], onProgress?: (completed: number, total: number) => void): Promise<(Agent | null)[]>;
+    /**
+     * Batch get only existing agent accounts
+     *
+     * Filters out non-existent addresses.
+     *
+     * @param addresses - Agent addresses to fetch
+     * @param onProgress - Optional progress callback
+     * @returns Array of existing agents with their addresses
+     *
+     * @example
+     * ```typescript
+     * const existingAgents = await client.agents.batchGetExistingAgents(['addr1', 'addr2'])
+     * // Returns: [{ address: 'addr1', account: Agent }, ...]
+     * ```
+     */
+    batchGetExistingAgents(addresses: Address$1[], onProgress?: (completed: number, total: number) => void): Promise<Array<{
+        address: Address$1;
+        account: Agent;
+    }>>;
+    /**
+     * Batch get and map agents to a simplified format
+     *
+     * Useful for creating agent summaries or lists.
+     *
+     * @param addresses - Agent addresses to fetch
+     * @param mapper - Transform function
+     * @returns Array of mapped results
+     *
+     * @example
+     * ```typescript
+     * const summaries = await client.agents.batchGetAndMapAgents(
+     *   addresses,
+     *   (agent, address) => agent ? {
+     *     address,
+     *     name: agent.name,
+     *     type: agent.agentType,
+     *     active: agent.isActive
+     *   } : null
+     * )
+     * ```
+     */
+    batchGetAndMapAgents<R>(addresses: Address$1[], mapper: (agent: Agent | null, address: Address$1, index: number) => R): Promise<R[]>;
+    private deriveAgentPda;
+    private deriveUserRegistryPda;
+    private deriveTreeConfigPda;
+    private get systemProgramId();
+    private get compressionProgramId();
+}
+
+interface ProposalType {
+    kind: 'ConfigChange' | 'Treasury' | 'Protocol' | 'Emergency';
+    data?: Record<string, unknown>;
+}
+interface ExecutionParams {
+    instructions: string[];
+    accounts: Address$1[];
+    targetProgram: Address$1;
+    executeAfter?: bigint;
+}
+interface CreateProposalParams {
+    title: string;
+    description: string;
+    proposalType: ProposalType;
+    executionParams: ExecutionParams;
+    proposalId: bigint;
+}
+/**
+ * Governance management module
+ *
+ * Provides high-level access to governance operations including:
+ * - Proposal creation and management
+ *
+ * NOTE: Voting, delegation, and execution are handled through protocol_config + multisig
+ */
+declare class GovernanceModule extends BaseModule {
+    /**
+     * Get initialize governance proposal instruction
+     */
+    getInitializeGovernanceProposalInstruction(params: {
+        proposal?: Address$1;
+        proposer: TransactionSigner;
+        title: string;
+        description: string;
+        proposalType: any;
+        executionParams: any;
+        proposalId: number | bigint;
+    }): Promise<InitializeGovernanceProposalInstruction<Address$1<"4wHjA2a5YC4twZb4NQpwZpixo5FgxxzuJUrCG7UnF9pB">, string, string, string, []>>;
+    /**
+     * Create a new governance proposal
+     */
+    createProposal(params: {
+        signer: TransactionSigner;
+        title: string;
+        description: string;
+        proposalType: 'parameter_change' | 'upgrade' | 'treasury';
+        votingDuration: number;
+        executionDelay?: number;
+    }): Promise<string>;
+    /**
+     * Get governance proposal account
+     */
+    getProposal(address: Address$1): Promise<GovernanceProposal | null>;
+    /**
+     * Get all active proposals
+     */
+    getActiveProposals(): Promise<{
+        address: Address$1;
+        data: GovernanceProposal;
+    }[]>;
+    /**
+     * Get proposals by proposer
+     */
+    getProposalsByProposer(proposer: Address$1): Promise<{
+        address: Address$1;
+        data: GovernanceProposal;
+    }[]>;
+    /**
+     * Get proposals by status
+     */
+    getProposalsByStatus(_status: 'draft' | 'voting' | 'succeeded' | 'defeated' | 'executed'): Promise<{
+        address: Address$1;
+        data: GovernanceProposal;
+    }[]>;
+    private deriveProposalPda;
+}
+
+interface CreateMultisigParams {
+    multisigId: bigint;
+    threshold: number;
+    signers: Address$1[];
+    config?: Partial<MultisigTypeConfigArgs>;
+    owner: TransactionSigner;
+}
+interface MultisigProposalParams {
+    multisigAddress: Address$1;
+    title: string;
+    description: string;
+    proposalType: ProposalTypeArgs;
+    executionParams: ExecutionParamsArgs;
+    proposalId: bigint;
+    proposer: TransactionSigner;
+}
+interface ExecuteProposalParams {
+    proposalAddress: Address$1;
+    executor: TransactionSigner;
+    targetProgram: Address$1;
+}
+declare class MultisigModule extends BaseModule {
+    /**
+     * Create a new multisig account
+     */
+    createMultisig(params: CreateMultisigParams): Promise<string>;
+    /**
+     * Create a proposal (Uses Governance Protocol)
+     *
+     * Note: This creates a GovernanceProposal. The proposer must be a signer.
+     */
+    createProposal(params: MultisigProposalParams): Promise<string>;
+    /**
+     * Execute a proposal (Note: Approval/voting removed, use protocol_config instead)
+     */
+    executeProposal(params: ExecuteProposalParams): Promise<string>;
+}
+
+/**
+ * GhostSpeak DID (Decentralized Identifier) Types
+ *
+ * Implements the did:sol method for Solana-based DIDs following W3C standards.
+ * Based on Identity.com's did:sol specification v3.0.
+ */
+
+/**
+ * Verification method type for DIDs
+ */
+declare enum VerificationMethodType {
+    /** Ed25519 verification key (Solana native) */
+    Ed25519VerificationKey2020 = "Ed25519VerificationKey2020",
+    /** X25519 key agreement for encryption */
+    X25519KeyAgreementKey2020 = "X25519KeyAgreementKey2020",
+    /** Secp256k1 verification key (Ethereum compatibility) */
+    EcdsaSecp256k1VerificationKey2019 = "EcdsaSecp256k1VerificationKey2019"
+}
+/**
+ * Verification relationship types
+ */
+declare enum VerificationRelationship {
+    /** Key can authenticate as the DID */
+    Authentication = "authentication",
+    /** Key can assert claims (issue credentials) */
+    AssertionMethod = "assertionMethod",
+    /** Key can perform key agreement (encryption) */
+    KeyAgreement = "keyAgreement",
+    /** Key can invoke capabilities (update DID document) */
+    CapabilityInvocation = "capabilityInvocation",
+    /** Key can delegate capabilities */
+    CapabilityDelegation = "capabilityDelegation"
+}
+/**
+ * Service endpoint type
+ */
+declare enum ServiceEndpointType {
+    /** AI agent service endpoint */
+    AIAgentService = "AIAgentService",
+    /** Messaging service endpoint (DIDComm) */
+    DIDCommMessaging = "DIDCommMessaging",
+    /** Credential repository */
+    CredentialRepository = "CredentialRepository",
+    /** Linked domains verification */
+    LinkedDomains = "LinkedDomains",
+    /** Custom service type */
+    Custom = "Custom"
+}
+/**
+ * Verification method for DID document
+ *
+ * Represents a cryptographic key that can be used to verify
+ * signatures or perform other cryptographic operations
+ */
+interface VerificationMethod {
+    /** Method identifier (e.g., "key-1") */
+    id: string;
+    /** Type of verification method */
+    methodType: VerificationMethodType;
+    /** DID of the controller (usually the DID itself) */
+    controller: string;
+    /** Public key in multibase format (base58btc) */
+    publicKeyMultibase: string;
+    /** Verification relationships this key has */
+    relationships: VerificationRelationship[];
+    /** Creation timestamp */
+    createdAt: number;
+    /** Revoked flag */
+    revoked: boolean;
+}
+/**
+ * Service endpoint in DID document
+ */
+interface ServiceEndpoint {
+    /** Service identifier (e.g., "agent-api") */
+    id: string;
+    /** Type of service */
+    serviceType: ServiceEndpointType;
+    /** Service endpoint URI */
+    serviceEndpoint: string;
+    /** Optional description */
+    description: string;
+}
+/**
+ * DID Document - main account for storing decentralized identifiers
+ *
+ * Follows W3C DID Core specification and did:sol method
+ */
+interface DidDocument {
+    /** The DID string (e.g., "did:sol:devnet:HN7cABqLq46Es1jh92dQQisAq662SmxELLLsHHe4YWrH") */
+    did: string;
+    /** Controller of the DID (can update the document) */
+    controller: Address$1;
+    /** Verification methods (public keys) */
+    verificationMethods: VerificationMethod[];
+    /** Service endpoints */
+    serviceEndpoints: ServiceEndpoint[];
+    /** Context URIs (for W3C compatibility) */
+    context: string[];
+    /** Also known as (alternative DIDs) */
+    alsoKnownAs: string[];
+    /** DID document creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+    /** Version number (incremented on each update) */
+    version: number;
+    /** Deactivated flag */
+    deactivated: boolean;
+    /** Deactivation timestamp (if deactivated) */
+    deactivatedAt?: number;
+    /** PDA bump */
+    bump: number;
+}
+/**
+ * DID Resolution Metadata
+ *
+ * Additional metadata for DID resolution
+ */
+interface DidResolutionMetadata {
+    /** DID being resolved */
+    did: string;
+    /** Pointer to the DID document account */
+    didDocument: Address$1;
+    /** Resolution timestamp */
+    resolvedAt: number;
+    /** Content type (application/did+json) */
+    contentType: string;
+    /** DID document version at resolution time */
+    version: number;
+    /** PDA bump */
+    bump: number;
+}
+/**
+ * W3C DID Document format for export
+ * Compliant with W3C DID Core specification
+ */
+interface W3CDidDocument {
+    '@context': string[];
+    id: string;
+    controller?: string | string[];
+    verificationMethod: Array<{
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase: string;
+    }>;
+    authentication?: Array<string | {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase: string;
+    }>;
+    assertionMethod?: string[];
+    keyAgreement?: string[];
+    capabilityInvocation?: string[];
+    capabilityDelegation?: string[];
+    service?: Array<{
+        id: string;
+        type: string;
+        serviceEndpoint: string;
+        description?: string;
+    }>;
+    alsoKnownAs?: string[];
+}
+/**
+ * Parameters for creating a DID document
+ */
+interface CreateDidDocumentParams {
+    /** Controller public key */
+    controller: Address$1;
+    /** Initial verification methods */
+    verificationMethods?: VerificationMethod[];
+    /** Initial service endpoints */
+    serviceEndpoints?: ServiceEndpoint[];
+    /** Network (mainnet, devnet, testnet) */
+    network?: 'mainnet' | 'devnet' | 'testnet';
+}
+/**
+ * Parameters for updating a DID document
+ */
+interface UpdateDidDocumentParams {
+    /** DID document address */
+    didDocument: Address$1;
+    /** Verification method to add */
+    addVerificationMethod?: VerificationMethod;
+    /** Verification method ID to remove */
+    removeVerificationMethodId?: string;
+    /** Service endpoint to add */
+    addServiceEndpoint?: ServiceEndpoint;
+    /** Service endpoint ID to remove */
+    removeServiceEndpointId?: string;
+}
+/**
+ * Parameters for deactivating a DID document
+ */
+interface DeactivateDidDocumentParams {
+    /** DID document address */
+    didDocument: Address$1;
+}
+/**
+ * Parameters for resolving a DID document
+ */
+interface ResolveDidDocumentParams {
+    /** DID string or controller address */
+    did: string | Address$1;
+}
+/**
+ * DID-related errors
+ */
+declare enum DidError {
+    AlreadyDeactivated = "AlreadyDeactivated",
+    TooManyVerificationMethods = "TooManyVerificationMethods",
+    TooManyServiceEndpoints = "TooManyServiceEndpoints",
+    DuplicateMethodId = "DuplicateMethodId",
+    DuplicateServiceId = "DuplicateServiceId",
+    MethodNotFound = "MethodNotFound",
+    ServiceNotFound = "ServiceNotFound",
+    InvalidDidFormat = "InvalidDidFormat",
+    UnauthorizedDidOperation = "UnauthorizedDidOperation",
+    DidDeactivated = "DidDeactivated"
+}
+/**
+ * DID Error class
+ */
+declare class DidErrorClass extends Error {
+    code: DidError;
+    constructor(code: DidError, message?: string);
+}
+
+/**
+ * GhostSpeak DID Helpers
+ *
+ * Utility functions for DID operations, validation, and W3C export
+ */
+
+/**
+ * Derive DID document PDA
+ * Pattern: ['did_document', controller]
+ */
+declare function deriveDidDocumentPda(programId: Address$1, controller: Address$1): Promise<[Address$1, number]>;
+/**
+ * Generate a did:sol string from network and public key
+ *
+ * @param network - Solana network (mainnet, devnet, testnet, localnet)
+ * @param pubkey - Public key to use as the DID identifier
+ * @returns DID string in the format "did:sol:network:pubkey"
+ *
+ * @example
+ * ```typescript
+ * const did = generateDidString('devnet', '5VKz...')
+ * // Returns: "did:sol:devnet:5VKz..."
+ * ```
+ */
+declare function generateDidString(network: 'mainnet' | 'devnet' | 'testnet' | 'localnet', pubkey: Address$1 | string): string;
+/**
+ * Validate DID string format
+ *
+ * @param did - DID string to validate
+ * @throws {DidErrorClass} If DID format is invalid
+ *
+ * @example
+ * ```typescript
+ * validateDidString('did:sol:devnet:5VKz...')
+ * // Returns: void (no error)
+ *
+ * validateDidString('invalid:did')
+ * // Throws: DidErrorClass
+ * ```
+ */
+declare function validateDidString(did: string): void;
+/**
+ * Parse a DID string into its components
+ *
+ * @param did - DID string to parse
+ * @returns Object with method, network, and identifier
+ *
+ * @example
+ * ```typescript
+ * const parts = parseDidString('did:sol:devnet:5VKz...')
+ * // Returns: { method: 'sol', network: 'devnet', identifier: '5VKz...' }
+ * ```
+ */
+declare function parseDidString(did: string): {
+    method: string;
+    network: string;
+    identifier: string;
+};
+/**
+ * Export a DID document as W3C-compliant format
+ *
+ * @param didDocument - DID document to export
+ * @returns W3C-compliant DID document
+ *
+ * @example
+ * ```typescript
+ * const w3cDoc = exportAsW3CDidDocument(didDocument)
+ * console.log(JSON.stringify(w3cDoc, null, 2))
+ * ```
+ */
+declare function exportAsW3CDidDocument(didDocument: DidDocument): W3CDidDocument;
+/**
+ * Create a default Ed25519 verification method
+ *
+ * @param id - Method identifier (e.g., "key-1")
+ * @param controller - Controller DID
+ * @param publicKey - Public key (Address or base58 string)
+ * @param relationships - Verification relationships
+ * @returns Verification method object
+ */
+declare function createEd25519VerificationMethod(id: string, controller: string, publicKey: Address$1 | string, relationships?: VerificationRelationship[]): VerificationMethod;
+/**
+ * Create a service endpoint
+ *
+ * @param id - Service identifier (e.g., "agent-api")
+ * @param serviceType - Type of service
+ * @param serviceEndpoint - Service endpoint URI
+ * @param description - Optional description
+ * @returns Service endpoint object
+ */
+declare function createServiceEndpoint(id: string, serviceType: string, serviceEndpoint: string, description?: string): ServiceEndpoint;
+/**
+ * Check if a DID document is active and can be used
+ *
+ * @param didDocument - DID document to check
+ * @returns True if active, false if deactivated
+ */
+declare function isDidActive(didDocument: DidDocument): boolean;
+/**
+ * Get verification methods for a specific relationship
+ *
+ * @param didDocument - DID document
+ * @param relationship - Verification relationship to filter by
+ * @returns Array of verification methods with the specified relationship
+ */
+declare function getMethodsForRelationship(didDocument: DidDocument, relationship: VerificationRelationship): VerificationMethod[];
+/**
+ * Check if a public key can perform a specific action
+ *
+ * @param didDocument - DID document
+ * @param publicKey - Public key to check
+ * @param relationship - Required verification relationship
+ * @returns True if the public key has the required relationship
+ */
+declare function canPerformAction(didDocument: DidDocument, publicKey: Address$1, relationship: VerificationRelationship): boolean;
+/**
+ * Convert a DID document to JSON string
+ *
+ * @param didDocument - DID document to convert
+ * @param pretty - Whether to pretty-print the JSON
+ * @returns JSON string representation
+ */
+declare function didDocumentToJson(didDocument: DidDocument, pretty?: boolean): string;
+/**
+ * Extract network from DID string
+ *
+ * @param did - DID string
+ * @returns Network identifier
+ */
+declare function getNetworkFromDid(did: string): string;
+/**
+ * Extract identifier (public key) from DID string
+ *
+ * @param did - DID string
+ * @returns Public key identifier
+ */
+declare function getIdentifierFromDid(did: string): string;
+
+/**
+ * GhostSpeak DID Module
+ *
+ * Provides functionality for managing Decentralized Identifiers (DIDs)
+ * following the W3C DID Core specification and did:sol method.
+ */
+
+/**
+ * DidModule - Manage decentralized identifiers on Solana
+ *
+ * @example
+ * ```typescript
+ * const client = new GhostSpeakClient({ cluster: 'devnet' })
+ * const did = client.did
+ *
+ * // Create a DID
+ * const signature = await did.create(signer, {
+ *   controller: signer.address,
+ *   network: 'devnet'
+ * })
+ *
+ * // Resolve a DID
+ * const didDoc = await did.resolve(signer.address)
+ *
+ * // Export as W3C format
+ * const w3c = await did.exportW3C(signer.address)
+ * ```
+ */
+declare class DidModule extends BaseModule {
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Create a new DID document
+     *
+     * @param signer - Transaction signer (will be the controller)
+     * @param params - DID creation parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await didModule.create(signer, {
+     *   controller: signer.address,
+     *   network: 'devnet',
+     *   verificationMethods: [{
+     *     id: 'key-1',
+     *     methodType: VerificationMethodType.Ed25519VerificationKey2020,
+     *     controller: 'did:sol:devnet:...',
+     *     publicKeyMultibase: 'z...',
+     *     relationships: [VerificationRelationship.Authentication],
+     *     createdAt: Date.now() / 1000,
+     *     revoked: false
+     *   }]
+     * })
+     * ```
+     */
+    create(signer: TransactionSigner, params: CreateDidDocumentParams): Promise<string>;
+    /**
+     * Update an existing DID document
+     *
+     * @param signer - Transaction signer (must be the controller)
+     * @param params - Update parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await didModule.update(signer, {
+     *   didDocument: didPda,
+     *   addVerificationMethod: {
+     *     id: 'key-2',
+     *     methodType: VerificationMethodType.X25519KeyAgreementKey2020,
+     *     controller: 'did:sol:devnet:...',
+     *     publicKeyMultibase: 'z...',
+     *     relationships: [VerificationRelationship.KeyAgreement],
+     *     createdAt: Date.now() / 1000,
+     *     revoked: false
+     *   }
+     * })
+     * ```
+     */
+    update(signer: TransactionSigner, params: UpdateDidDocumentParams): Promise<string>;
+    /**
+     * Deactivate a DID document (irreversible)
+     *
+     * @param signer - Transaction signer (must be the controller)
+     * @param params - Deactivation parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await didModule.deactivate(signer, {
+     *   didDocument: didPda
+     * })
+     * ```
+     */
+    deactivate(signer: TransactionSigner, params: DeactivateDidDocumentParams): Promise<string>;
+    /**
+     * Resolve a DID document
+     *
+     * @param didOrController - DID string or controller address
+     * @returns DID document or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Resolve by controller address
+     * const didDoc = await didModule.resolve(controllerAddress)
+     *
+     * // Resolve by DID string
+     * const didDoc = await didModule.resolve('did:sol:devnet:5VKz...')
+     * ```
+     */
+    resolve(didOrController: string | Address$1): Promise<DidDocument | null>;
+    /**
+     * Export a DID document as W3C-compliant JSON
+     *
+     * @param didOrController - DID string or controller address
+     * @param pretty - Whether to pretty-print the JSON
+     * @returns W3C DID document JSON string
+     *
+     * @example
+     * ```typescript
+     * const json = await didModule.exportW3C(controllerAddress, true)
+     * console.log(json)
+     * ```
+     */
+    exportW3C(didOrController: string | Address$1, pretty?: boolean): Promise<string | null>;
+    /**
+     * Get W3C DID document object
+     *
+     * @param didOrController - DID string or controller address
+     * @returns W3C DID document object or null
+     */
+    getW3CDocument(didOrController: string | Address$1): Promise<W3CDidDocument | null>;
+    /**
+     * Derive DID document PDA for a controller
+     *
+     * @param controller - Controller address
+     * @returns DID document PDA and bump
+     */
+    deriveDidPda(controller: Address$1): Promise<[Address$1, number]>;
+    /**
+     * Generate a DID string for a controller
+     *
+     * @param controller - Controller address
+     * @param network - Network identifier
+     * @returns DID string
+     */
+    generateDid(controller: Address$1, network?: 'mainnet' | 'devnet' | 'testnet'): string;
+    /**
+     * Validate a DID string
+     *
+     * @param did - DID string to validate
+     * @returns True if valid, throws error if invalid
+     */
+    validateDid(did: string): boolean;
+    /**
+     * Check if a DID is active
+     *
+     * @param didOrController - DID string or controller address
+     * @returns True if active, false if deactivated or not found
+     */
+    isActive(didOrController: string | Address$1): Promise<boolean>;
+    /**
+     * Build create DID instruction manually
+     * Note: This is temporary until DID instructions are generated from IDL
+     */
+    private buildCreateDidInstruction;
+    /**
+     * Build update DID instruction manually
+     * Note: This is temporary until DID instructions are generated from IDL
+     */
+    private buildUpdateDidInstruction;
+    /**
+     * Build deactivate DID instruction manually
+     * Note: This is temporary until DID instructions are generated from IDL
+     */
+    private buildDeactivateDidInstruction;
+    /**
+     * Create an Ed25519 verification method
+     */
+    static createVerificationMethod: typeof createEd25519VerificationMethod;
+    /**
+     * Create a service endpoint
+     */
+    static createServiceEndpoint: typeof createServiceEndpoint;
+}
+
+/**
+ * GhostSpeak Credential Module
+ *
+ * Provides functionality for creating, signing, and exporting
+ * W3C-compatible Verifiable Credentials with DID integration.
+ */
+
+declare enum CredentialKind {
+    AgentIdentity = "AgentIdentity",
+    ReputationScore = "ReputationScore",
+    JobCompletion = "JobCompletion",
+    DelegatedSigner = "DelegatedSigner",
+    Custom = "Custom"
+}
+declare enum CredentialStatus {
+    Pending = "Pending",
+    Active = "Active",
+    Revoked = "Revoked",
+    Expired = "Expired"
+}
+interface CredentialType {
+    authority: string;
+    name: string;
+    kind: CredentialKind;
+    schemaUri: string;
+    description: string;
+    isActive: boolean;
+    totalIssued: number;
+    createdAt: number;
+}
+interface CredentialTemplate {
+    credentialType: string;
+    name: string;
+    imageUri: string;
+    issuer: string;
+    isActive: boolean;
+    totalIssued: number;
+    createdAt: number;
+    crossmintTemplateId?: string;
+}
+interface Credential {
+    template: string;
+    subject: string;
+    issuer: string;
+    credentialId: string;
+    subjectDataHash: Uint8Array;
+    subjectDataUri: string;
+    status: CredentialStatus;
+    signature: Uint8Array;
+    issuedAt: number;
+    expiresAt?: number;
+    revokedAt?: number;
+    crossmintCredentialId?: string;
+}
+interface W3CVerifiableCredential {
+    '@context': string[];
+    type: string[];
+    id: string;
+    issuer: {
+        id: string;
+        name?: string;
+    } | string;
+    validFrom: string;
+    validUntil?: string;
+    credentialSubject: {
+        id?: string;
+        [key: string]: unknown;
+    };
+    credentialSchema?: {
+        id: string;
+        type: 'JsonSchema';
+    };
+    credentialStatus?: {
+        id: string;
+        type: string;
+        statusPurpose: 'revocation' | 'suspension';
+    };
+    relatedResource?: Array<{
+        id: string;
+        digestMultibase?: string;
+    }>;
+    proof: {
+        type: 'DataIntegrityProof';
+        created: string;
+        verificationMethod: string;
+        cryptosuite: 'eddsa-rdfc-2022';
+        proofPurpose: 'assertionMethod';
+        proofValue: string;
+    };
+}
+declare class CredentialModule {
+    private programId;
+    private didModule?;
+    constructor(programId?: Address$1, didModule?: DidModule);
+    /**
+     * Set the DID module for enhanced DID resolution
+     * This enables automatic DID creation and resolution for credentials
+     */
+    setDidModule(didModule: DidModule): void;
+    hashSubjectData(subjectData: Record<string, unknown>): Uint8Array;
+    generateCredentialId(kind: CredentialKind, subject: string): string;
+    exportAsW3CCredential(credential: Credential, template: CredentialTemplate, credentialType: CredentialType, subjectData: Record<string, unknown>, options?: {
+        network?: 'mainnet' | 'devnet' | 'testnet';
+        includeRelatedResource?: boolean;
+    }): W3CVerifiableCredential;
+    /**
+     * Export credential with DID resolution
+     * Resolves DIDs for issuer and subject to get full DID documents
+     *
+     * @param credential - Credential to export
+     * @param template - Credential template
+     * @param credentialType - Credential type
+     * @param subjectData - Subject data
+     * @param options - Export options
+     * @returns W3C credential with resolved DIDs
+     */
+    exportWithDidResolution(credential: Credential, template: CredentialTemplate, credentialType: CredentialType, subjectData: Record<string, unknown>, options?: {
+        network?: 'mainnet' | 'devnet' | 'testnet';
+        includeRelatedResource?: boolean;
+    }): Promise<W3CVerifiableCredential>;
+    static buildAgentIdentitySubject(params: {
+        agentId: string;
+        owner: string;
+        name: string;
+        capabilities: string[];
+        serviceEndpoint: string;
+        frameworkOrigin: string;
+        x402Enabled: boolean;
+        registeredAt: number;
+        verifiedAt: number;
+    }): {
+        agentId: string;
+        owner: string;
+        name: string;
+        capabilities: string[];
+        serviceEndpoint: string;
+        frameworkOrigin: string;
+        x402Enabled: boolean;
+        registeredAt: number;
+        verifiedAt: number;
+    };
+    /**
+     * Issue an AgentIdentity credential for a newly registered x402 agent
+     *
+     * This creates a W3C Verifiable Credential that can be:
+     * - Stored on-chain for reputation
+     * - Exported as standard W3C VC JSON
+     * - Verified by third parties
+     *
+     * @example
+     * ```typescript
+     * const result = await credentialModule.issueX402AgentCredential({
+     *   agentAddress: 'EPjFWdd5...',
+     *   agentId: 'x402-abc123',
+     *   owner: 'HN7cAB...',
+     *   name: 'My Coinbase Agent',
+     *   serviceEndpoint: 'https://my-agent.com/api',
+     *   frameworkOrigin: 'coinbase-x402',
+     *   x402PaymentAddress: 'EPjFWdd5...',
+     *   x402AcceptedTokens: ['EPjFWdd5...'],
+     *   x402PricePerCall: '1000000'
+     * })
+     * ```
+     */
+    issueX402AgentCredential(params: {
+        agentAddress: string;
+        agentId: string;
+        owner: string;
+        name: string;
+        serviceEndpoint: string;
+        frameworkOrigin: string;
+        x402PaymentAddress: string;
+        x402AcceptedTokens: string[];
+        x402PricePerCall: string;
+        capabilities?: string[];
+        description?: string;
+        verificationResponseTimeMs?: number;
+        network?: 'mainnet' | 'devnet' | 'testnet';
+    }): {
+        credentialId: string;
+        credential: Credential;
+        w3cCredential: W3CVerifiableCredential;
+        subjectData: Record<string, unknown>;
+    };
+    /**
+     * Export an existing credential to W3C JSON format
+     */
+    exportCredentialToJSON(credential: Credential, subjectData: Record<string, unknown>, options?: {
+        network?: 'mainnet' | 'devnet' | 'testnet';
+        pretty?: boolean;
+    }): string;
+}
+
+/**
+ * PayAI x402 Client
+ *
+ * Client for making x402 payments through the PayAI facilitator.
+ * Wraps the standard fetch API with automatic payment handling.
+ *
+ * @module payai/PayAIClient
+ * @see https://docs.payai.network/x402/introduction
+ */
+
+/**
+ * Check if a response requires payment
+ */
+declare function isPaymentRequired(response: Response): boolean;
+/**
+ * Extract payment requirements from a 402 response
+ */
+declare function extractPaymentRequirements(response: Response): Promise<PayAIPaymentRequirement[]>;
+declare class PayAIClient extends EventEmitter {
+    private readonly config;
+    private readonly localRecords;
+    constructor(config: PayAIClientConfig);
+    /**
+     * Make a fetch request with automatic x402 payment handling
+     *
+     * @param url - The resource URL
+     * @param init - Fetch options
+     * @returns Response from the resource
+     */
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Verify a payment through the PayAI facilitator
+     *
+     * @param paymentHeader - The payment header/payload
+     * @param requirement - The payment requirement
+     * @returns Verification result
+     */
+    verifyPayment(paymentHeader: string, requirement: PayAIPaymentRequirement): Promise<{
+        valid: boolean;
+        payer?: string;
+        error?: string;
+    }>;
+    /**
+     * Settle a payment through the PayAI facilitator
+     *
+     * @param paymentHeader - The payment header/payload
+     * @param requirement - The payment requirement
+     * @returns Settlement result
+     */
+    settlePayment(paymentHeader: string, requirement: PayAIPaymentRequirement): Promise<{
+        success: boolean;
+        transaction?: string;
+        error?: string;
+    }>;
+    /**
+     * List available resources from the PayAI facilitator
+     *
+     * @param options - Filter options
+     * @returns List of available resources
+     */
+    listResources(options?: {
+        network?: PayAINetwork;
+        capability?: string;
+        maxPrice?: number;
+    }): Promise<{
+        resources: Array<{
+            url: string;
+            description?: string;
+            accepts: PayAIPaymentRequirement[];
+            tags?: string[];
+        }>;
+    }>;
+    /**
+     * Get locally tracked reputation records
+     * (For payments made through this client instance)
+     */
+    getLocalReputationRecords(): PayAIReputationRecord[];
+    /**
+     * Clear local reputation records
+     */
+    clearLocalReputationRecords(): void;
+    /**
+     * Select the best payment option from requirements
+     */
+    private selectPaymentOption;
+    /**
+     * Make payment and retry the original request
+     */
+    private makePaymentAndRetry;
+    /**
+     * Create a payment header for a requirement
+     * (In production, this would sign a real Solana transaction)
+     */
+    private createPaymentHeader;
+    /**
+     * Fetch with timeout
+     */
+    private fetchWithTimeout;
+}
+/**
+ * Create a new PayAI client
+ *
+ * @param config - Client configuration
+ * @returns Configured PayAI client
+ */
+declare function createPayAIClient(config: PayAIClientConfig): PayAIClient;
+/**
+ * Make a single x402 payment request through PayAI
+ *
+ * @param url - Resource URL
+ * @param config - Client configuration
+ * @param init - Fetch options
+ * @returns Response from the resource
+ */
+declare function payAIFetch(url: string, config: PayAIClientConfig, init?: RequestInit): Promise<Response>;
+
+/**
+ * Simplified reputation data for module use
+ */
+interface ReputationData {
+    agent: Address$1;
+    overallScore: number;
+    totalJobsCompleted: number;
+    totalJobsFailed: number;
+    avgResponseTime: number;
+    disputesAgainst: number;
+    disputesResolved: number;
+    lastUpdated: number;
+    categoryReputations: CategoryReputation[];
+    badges: Array<{
+        badgeType: BadgeType;
+        earnedAt: number;
+    }>;
+    performanceHistory: Array<{
+        timestamp: number;
+        score: number;
+        jobsCompleted: number;
+        avgQuality: number;
+    }>;
+    factors: {
+        completionWeight: number;
+        qualityWeight: number;
+        timelinessWeight: number;
+        satisfactionWeight: number;
+        disputeWeight: number;
+    };
+}
+/**
+ * Reputation module for managing reputation calculations
+ */
+declare class ReputationModule extends BaseModule {
+    private calculator;
+    private tagEngine;
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Calculate reputation change for a job
+     */
+    calculateReputationChange(currentData: ReputationData, jobPerformance: JobPerformance): ReputationCalculationResult;
+    /**
+     * Get tier name from tier enum
+     */
+    getTierName(tier: ReputationTier): string;
+    /**
+     * Get tier from score
+     */
+    getTierFromScore(score: number): ReputationTier;
+    /**
+     * Get badge display name
+     */
+    getBadgeName(badge: BadgeType): string;
+    /**
+     * Calculate estimated APY boost from reputation
+     */
+    calculateApyBoost(score: number): number;
+    /**
+     * Get reputation tier color for UI
+     */
+    getTierColor(tier: ReputationTier): string;
+    /**
+     * Create default reputation data for new agents
+     */
+    createDefaultReputationData(agentAddress: Address$1): ReputationData;
+    /**
+     * Check if agent qualifies for a specific tier
+     */
+    qualifiesForTier(score: number, tier: ReputationTier): boolean;
+    /**
+     * Calculate points needed for next tier
+     */
+    pointsToNextTier(score: number): {
+        nextTier: ReputationTier;
+        pointsNeeded: number;
+    } | null;
+    /**
+     * Record a PayAI payment event to update reputation
+     *
+     * Converts PayAI webhook data to JobPerformance format and
+     * calculates reputation change.
+     *
+     * @param record - PayAI reputation record from webhook
+     * @param currentData - Current agent reputation data (fetched from on-chain or cache)
+     * @returns Reputation calculation result
+     */
+    recordPayAIPayment(record: PayAIReputationRecordInput, currentData: ReputationData): ReputationCalculationResult;
+    /**
+     * Convert a PayAI reputation record to JobPerformance format
+     *
+     * PayAI provides basic payment data, so we derive quality metrics
+     * from response time and success status.
+     */
+    payAIRecordToJobPerformance(record: PayAIReputationRecordInput): JobPerformance;
+    /**
+     * Estimate quality rating from response time
+     *
+     * Fast responses (< 500ms) = 100 quality
+     * Average responses (500ms-2s) = 70-90 quality
+     * Slow responses (2s-10s) = 40-70 quality
+     * Very slow responses (> 10s) = 20-40 quality
+     */
+    private estimateQualityFromResponseTime;
+    /**
+     * Estimate expected duration based on payment amount
+     *
+     * Larger payments = longer expected processing time
+     */
+    private estimateExpectedDuration;
+    /**
+     * Categorize payment by network
+     */
+    private categorizeFromNetwork;
+    /**
+     * Create a PayAI-compatible performance snapshot
+     * Useful for tracking payment patterns
+     */
+    createPayAIPerformanceSnapshot(record: PayAIReputationRecordInput, reputationResult: ReputationCalculationResult): {
+        timestamp: number;
+        paymentId: string;
+        network: string;
+        amount: string;
+        success: boolean;
+        responseTimeMs: number;
+        reputationChange: number;
+        newScore: number;
+        tier: string;
+    };
+    /**
+     * Calculate tags for an agent based on metrics
+     *
+     * Automatically evaluates all tag criteria and assigns tags
+     * with appropriate confidence scores.
+     *
+     * @param metrics - Agent reputation metrics
+     * @returns Array of tag scores
+     */
+    calculateTagsForAgent(metrics: ReputationMetrics): Promise<TagScore[]>;
+    /**
+     * Get tags by category
+     *
+     * Filters tags to only those in the specified category.
+     *
+     * @param tags - All tag scores
+     * @param category - Category to filter by
+     * @returns Filtered tag scores
+     */
+    getTagsByCategory(tags: TagScore[], category: TagCategory): TagScore[];
+    /**
+     * Check if agent has a specific tag
+     *
+     * @param tags - Agent's tag scores
+     * @param tagName - Tag to check for
+     * @returns Whether the tag exists
+     */
+    hasTag(tags: TagScore[], tagName: string): boolean;
+    /**
+     * Get tag confidence score
+     *
+     * @param tags - Agent's tag scores
+     * @param tagName - Tag to check
+     * @returns Confidence score or undefined if tag doesn't exist
+     */
+    getTagConfidence(tags: TagScore[], tagName: string): number | undefined;
+    /**
+     * Filter tags by criteria
+     *
+     * @param tags - Tags to filter
+     * @param filters - Filter criteria
+     * @returns Filtered tags
+     */
+    filterTags(tags: TagScore[], filters: TagFilters): TagScore[];
+    /**
+     * Apply tag decay based on age
+     *
+     * Reduces confidence scores for old tags and removes stale tags.
+     *
+     * @param tags - Current tag scores
+     * @param currentTimestamp - Current Unix timestamp (optional)
+     * @returns Tags with decay applied
+     */
+    applyTagDecay(tags: TagScore[], currentTimestamp?: number): TagScore[];
+    /**
+     * Merge new tags with existing tags
+     *
+     * Updates existing tags or adds new ones, preferring higher confidence.
+     *
+     * @param existingTags - Current tags
+     * @param newTags - New tags to merge
+     * @returns Merged tag list
+     */
+    mergeTags(existingTags: TagScore[], newTags: TagScore[]): TagScore[];
+    /**
+     * Categorize tags by type
+     *
+     * Organizes tags into skill, behavior, and compliance categories.
+     *
+     * @param tags - Tags to categorize
+     * @returns Categorized tag result
+     */
+    categorizeTags(tags: TagScore[]): TagQueryResult;
+    /**
+     * Get top N tags by confidence
+     *
+     * @param tags - Tags to sort
+     * @param count - Number of tags to return
+     * @returns Top tags
+     */
+    getTopTags(tags: TagScore[], count: number): TagScore[];
+    /**
+     * Sort tags by confidence (descending)
+     *
+     * @param tags - Tags to sort
+     * @returns Sorted tags
+     */
+    sortTagsByConfidence(tags: TagScore[]): TagScore[];
+    /**
+     * Sort tags by evidence count (descending)
+     *
+     * @param tags - Tags to sort
+     * @returns Sorted tags
+     */
+    sortTagsByEvidence(tags: TagScore[]): TagScore[];
+    /**
+     * Sort tags by most recently updated
+     *
+     * @param tags - Tags to sort
+     * @returns Sorted tags
+     */
+    sortTagsByRecent(tags: TagScore[]): TagScore[];
+    /**
+     * Get confidence level description
+     *
+     * @param confidence - Confidence score (0-10000)
+     * @returns Human-readable confidence level
+     */
+    getConfidenceLevel(confidence: number): string;
+    /**
+     * Validate tag name length
+     *
+     * @param tagName - Tag name to validate
+     * @returns Whether tag name is valid
+     */
+    validateTagName(tagName: string): boolean;
+    /**
+     * Validate confidence score
+     *
+     * @param confidence - Confidence to validate
+     * @returns Whether confidence is valid (0-10000)
+     */
+    validateConfidence(confidence: number): boolean;
+    /**
+     * Convert on-chain ReputationMetrics to TagEngine format
+     *
+     * Helper to convert blockchain data to the format needed for tag calculation.
+     *
+     * @param onChainMetrics - Metrics from blockchain
+     * @returns Metrics in TagEngine format
+     */
+    convertMetricsForTagging(onChainMetrics: {
+        successfulPayments: bigint;
+        failedPayments: bigint;
+        totalResponseTime: bigint;
+        responseTimeCount: bigint;
+        totalDisputes: number;
+        disputesResolved: number;
+        totalRating: number;
+        totalRatingsCount: number;
+        createdAt: number;
+        updatedAt: number;
+    }): ReputationMetrics;
+}
+/**
+ * Interface for PayAI reputation record input
+ * Matches the PayAIReputationRecord from payai module
+ */
+interface PayAIReputationRecordInput {
+    agentAddress: Address$1;
+    paymentSignature: string;
+    amount: bigint;
+    success: boolean;
+    responseTimeMs: number;
+    payerAddress: string;
+    timestamp: Date;
+    network: string;
+}
+
+interface StakeParams {
+    /** Agent address to stake for */
+    agent: Address$1;
+    /** Agent's token account holding GHOST tokens */
+    agentTokenAccount: Address$1;
+    /** Staking vault to receive tokens */
+    stakingVault: Address$1;
+    /** Global staking config account */
+    stakingConfig: Address$1;
+    /** GHOST token mint address */
+    ghostMint: Address$1;
+    /** Amount of GHOST tokens to stake (in lamports) */
+    amount: bigint;
+    /** Lock duration in seconds */
+    lockDuration: bigint;
+    /** The agent owner's transaction signer */
+    agentOwner: TransactionSigner;
+}
+interface UnstakeParams {
+    /** Staking account to unstake from */
+    stakingAccount: Address$1;
+    /** Agent address */
+    agent: Address$1;
+    /** Staking vault holding the tokens */
+    stakingVault: Address$1;
+    /** Agent's token account to receive tokens */
+    agentTokenAccount: Address$1;
+    /** The agent owner's transaction signer */
+    agentOwner: TransactionSigner;
+}
+interface InitializeStakingConfigParams {
+    /** Admin who can modify staking config */
+    authority: TransactionSigner;
+    /** Minimum stake amount */
+    minStake: bigint;
+    /** Treasury address to receive fees */
+    treasury: Address$1;
+}
+declare class StakingModule extends BaseModule {
+    /**
+     * Initialize the global staking configuration (admin only)
+     */
+    initializeStakingConfig(params: InitializeStakingConfigParams): Promise<string>;
+    /**
+     * Stake GHOST tokens for an agent
+     *
+     * @param params - Staking parameters
+     * @returns Transaction signature
+     */
+    stake(params: StakeParams): Promise<string>;
+    /**
+     * Unstake GHOST tokens from an agent
+     *
+     * @param params - Unstaking parameters
+     * @returns Transaction signature
+     */
+    unstake(params: UnstakeParams): Promise<string>;
+    /**
+     * Get staking account for an agent
+     *
+     * @param stakingAccountAddress - The staking account address
+     * @returns Staking account data or null if not found
+     */
+    getStakingAccount(stakingAccountAddress: Address$1): Promise<StakingAccount | null>;
+    /**
+     * Get the global staking configuration
+     *
+     * @param stakingConfigAddress - The staking config account address
+     * @returns Staking config data or null if not initialized
+     */
+    getStakingConfig(stakingConfigAddress: Address$1): Promise<StakingConfig | null>;
+}
+
+export { type ServiceEndpoint as $, AgentModule as A, BaseModule as B, CacheManager as C, DidModule as D, type ExtendedRpcApi as E, generateDidString as F, type GhostSpeakConfig as G, validateDidString as H, InstructionBuilder as I, parseDidString as J, exportAsW3CDidDocument as K, createEd25519VerificationMethod as L, MultisigModule as M, createServiceEndpoint as N, isDidActive as O, PayAIClient as P, getMethodsForRelationship as Q, ReputationModule as R, StakingModule as S, canPerformAction as T, didDocumentToJson as U, VerificationMethodType as V, type W3CVerifiableCredential as W, getNetworkFromDid as X, getIdentifierFromDid as Y, type DidDocument as Z, type VerificationMethod as _, GovernanceModule as a, type DidResolutionMetadata as a0, type W3CDidDocument as a1, type CreateDidDocumentParams as a2, type UpdateDidDocumentParams as a3, type DeactivateDidDocumentParams as a4, type ResolveDidDocumentParams as a5, type ReputationData as a6, type PayAIReputationRecordInput as a7, createPayAIClient as a8, payAIFetch as a9, type RpcSubscriptionApi as aA, type StakingAccount as aB, type StakingConfig as aC, getAgentDecoder as aD, getStakingAccountDecoder as aE, getStakingConfigDecoder as aF, type Agent as aG, isPaymentRequired as aa, extractPaymentRequirements as ab, type PayAIWebhookEventType as ac, type PayAIPaymentStatus as ad, type PayAIClientConfig as ae, type PayAIPaymentRequirement as af, type PayAIPaymentResponse as ag, type AgentWithAddress as ah, type AgentRegistrationData as ai, type AgentAccount as aj, PricingModel as ak, GhostSpeakError as al, type RegisterAgentParams as am, type RpcResponse as an, type RpcAccountInfo as ao, type RpcProgramAccount as ap, type RpcProgramAccountsResponse as aq, type RpcAccountInfoResponse as ar, type RpcMultipleAccountsResponse as as, type TransactionResponse as at, type SimulatedTransactionResponse as au, type SolanaRpcClient as av, type EmergencyConfig as aw, type Commitment as ax, type RetryConfig as ay, type RpcApi as az, AccessTier as b, GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS as c, type PricingModelArgs as d, type PayAIWebhookHandlerOptions as e, type PayAIWebhookPayload as f, type PayAIWebhookResult as g, type PayAIWebhookVerification as h, type PayAIPaymentData as i, type PayAIReputationRecord as j, type PayAINetwork as k, type PayAIAgentRegistration as l, type CacheConfig as m, type CreateProposalParams as n, type ProposalType as o, type ExecutionParams as p, CredentialModule as q, CredentialKind as r, CredentialStatus as s, type Credential as t, type CredentialTemplate as u, VerificationRelationship as v, ServiceEndpointType as w, DidError as x, DidErrorClass as y, deriveDidDocumentPda as z };