@ghostspeak/sdk 2.0.6 → 2.0.8

package/dist/StakingModule-DunDShLq.d.ts

@@ -0,0 +1,2446 @@
+import { Address as Address$1 } from '@solana/addresses';
+import { ReadonlyUint8Array, Option, Address, Decoder, EncodedAccount, Account, MaybeEncodedAccount, MaybeAccount, fetchEncodedAccount, FetchAccountConfig, 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 { 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
+ */
+
+/** Agent lifecycle status (Ghost Identity) */
+declare enum AgentStatus {
+    Unregistered = 0,
+    Registered = 1,
+    Claimed = 2,
+    Verified = 3
+}
+
+/**
+ * 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
+ */
+
+/** Cross-platform identity mapping */
+type ExternalIdentifier = {
+    platform: string;
+    externalId: string;
+    verified: boolean;
+    verifiedAt: 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
+ */
+
+/**
+ * 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
+ */
+
+/** Reputation component for multi-source Ghost Score */
+type ReputationComponent = {
+    sourceType: ReputationSourceType;
+    score: bigint;
+    weight: number;
+    lastUpdated: bigint;
+    dataPoints: 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
+ */
+
+/** Multi-source reputation types for Ghost Score */
+declare enum ReputationSourceType {
+    AccountAge = 0,
+    X402Transactions = 1,
+    UserReviews = 2,
+    ElizaOSReputation = 3,
+    CrossmintVerification = 4,
+    EndpointReliability = 5,
+    JobCompletions = 6,
+    SkillEndorsements = 7
+}
+
+/**
+ * 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: Option<Address>;
+    status: AgentStatus;
+    agentId: string;
+    firstTxSignature: string;
+    firstSeenTimestamp: bigint;
+    discoverySource: string;
+    claimedAt: Option<bigint>;
+    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;
+    externalIdentifiers: Array<ExternalIdentifier>;
+    ghostScore: bigint;
+    reputationComponents: Array<ReputationComponent>;
+    didAddress: Option<Address>;
+    credentials: Array<Address>;
+    apiSpecUri: string;
+    apiVersion: string;
+    bump: number;
+};
+/** Gets the decoder for {@link Agent} account data. */
+declare function getAgentDecoder(): Decoder<Agent>;
+declare function decodeAgent<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Agent, TAddress>;
+declare function decodeAgent<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Agent, TAddress>;
+declare function fetchAgent<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Agent, TAddress>>;
+declare function fetchMaybeAgent<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Agent, TAddress>>;
+
+/**
+ * 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
+]>;
+
+/**
+ * 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;
+}
+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();
+}
+
+/**
+ * Ghost Module - Claim and manage external AI agents
+ *
+ * This module provides methods for claiming "Ghost" agents (external agents
+ * registered on x402 facilitators like PayAI) using the Solana Attestation
+ * Service (SAS) for trustless ownership verification.
+ */
+
+/**
+ * Network identifier for DID generation
+ */
+type Network = 'devnet' | 'testnet' | 'mainnet-beta' | 'localnet';
+/**
+ * Parameters for claiming a Ghost
+ */
+interface ClaimGhostParams {
+    /** Agent account address (the external agent to claim) */
+    agentAddress: Address$1;
+    /** x402 payment address of the agent (used for PDA derivation) */
+    x402PaymentAddress: Address$1;
+    /** SAS Credential address (issuer) */
+    sasCredential: Address$1;
+    /** SAS Schema address (defines attestation structure) */
+    sasSchema: Address$1;
+    /** Network identifier for DID (e.g., "devnet", "mainnet-beta") */
+    network: Network;
+    /** Optional IPFS metadata URI (ipfs://...) */
+    ipfsMetadataUri?: string;
+    /** Optional GitHub username for social proof */
+    githubUsername?: string;
+    /** Optional Twitter handle for social proof */
+    twitterHandle?: string;
+}
+/**
+ * Result of preparing a Ghost claim
+ */
+interface PreparedClaimResult {
+    /** Derived attestation PDA */
+    attestationPda: Address$1;
+    /** Derived DID document PDA */
+    didDocumentPda: Address$1;
+    /** Attestation bump seed */
+    attestationBump: number;
+    /** DID document bump seed */
+    didDocumentBump: number;
+}
+/**
+ * Ghost Module - Manage external agent claims
+ */
+declare class GhostModule extends BaseModule {
+    constructor(config: GhostSpeakConfig);
+    /**
+     * Claim ownership of a Ghost using SAS attestation
+     *
+     * This method performs the complete claim flow:
+     * 1. Derives required PDAs (attestation, DID document)
+     * 2. Builds the claim_ghost instruction
+     * 3. Executes the transaction
+     *
+     * **Prerequisites:**
+     * - The claimer must have already created a SAS attestation proving ownership
+     *   of the agent's x402_payment_address
+     * - The agent must be in Unregistered or Registered status (not already claimed)
+     *
+     * **Results:**
+     * - Agent status transitions to Claimed
+     * - DID document is auto-created with did:sol:<network>:<address>
+     * - Claimer becomes the owner of the agent
+     *
+     * @param claimer - Transaction signer (must own the SAS attestation)
+     * @param params - Claim parameters
+     * @returns Transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await client.ghosts.claim(signer, {
+     *   agentAddress: 'GhostAgent123...',
+     *   x402PaymentAddress: 'PaymentAddr456...',
+     *   sasCredential: 'SASCredential789...',
+     *   sasSchema: 'SASSchema012...',
+     *   network: 'devnet',
+     *   ipfsMetadataUri: 'ipfs://QmHash...',
+     *   githubUsername: 'myusername'
+     * })
+     * ```
+     */
+    claim(claimer: TransactionSigner, params: ClaimGhostParams): Promise<string>;
+    /**
+     * Prepare a Ghost claim by deriving all required PDAs
+     *
+     * This is useful for:
+     * - Pre-flight validation (checking if PDAs are correct)
+     * - Building custom transactions with manual PDA management
+     * - Debugging claim issues
+     *
+     * @param params - Claim parameters
+     * @returns Prepared claim data with derived PDAs
+     *
+     * @example
+     * ```typescript
+     * const prepared = await client.ghosts.prepareClaim({
+     *   agentAddress: 'GhostAgent123...',
+     *   x402PaymentAddress: 'PaymentAddr456...',
+     *   sasCredential: 'SASCredential789...',
+     *   sasSchema: 'SASSchema012...',
+     *   network: 'devnet'
+     * })
+     *
+     * console.log('Attestation PDA:', prepared.attestationPda)
+     * console.log('DID Document PDA:', prepared.didDocumentPda)
+     * ```
+     */
+    prepareClaim(params: ClaimGhostParams): Promise<PreparedClaimResult>;
+    /**
+     * Get Ghost agent account
+     *
+     * @param address - Agent account address
+     * @returns Agent account data or null if not found
+     */
+    getGhostAgent(address: Address$1): Promise<Agent | null>;
+    /**
+     * Get all Ghost agents (agents with type 10 - external x402 agents)
+     *
+     * @returns Array of Ghost agents
+     */
+    getAllGhosts(): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Get Ghost agents by type
+     *
+     * @param agentType - Agent type filter (default: 10 for x402 ghosts)
+     * @returns Array of matching Ghost agents
+     */
+    getGhostsByType(agentType?: number): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Get claimed Ghosts by owner
+     *
+     * @param owner - Owner address
+     * @returns Array of Ghost agents owned by the address
+     */
+    getClaimedGhosts(owner: Address$1): Promise<{
+        address: Address$1;
+        data: Agent;
+    }[]>;
+    /**
+     * Validate claim parameters
+     *
+     * Performs pre-flight checks to ensure claim will succeed:
+     * - Agent exists and is in correct status
+     * - Agent is not already claimed
+     * - PDAs are correctly derived
+     *
+     * @param params - Claim parameters
+     * @returns Validation result with error messages if any
+     */
+    validateClaim(params: ClaimGhostParams): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Derive DID document PDA
+     *
+     * Pattern: ['did_document', x402_payment_address]
+     *
+     * @param x402PaymentAddress - Agent's x402 payment address
+     * @returns [DID document PDA, bump]
+     */
+    private deriveDidDocumentPda;
+    private get systemProgramId();
+}
+
+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;
+}
+
+/**
+ * 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 DeactivateDidDocumentParams as $, AgentModule as A, BaseModule as B, CacheManager as C, DidModule as D, type ExtendedRpcApi as E, isDidActive as F, type GhostSpeakConfig as G, getMethodsForRelationship as H, InstructionBuilder as I, canPerformAction as J, didDocumentToJson as K, getNetworkFromDid as L, MultisigModule as M, type Network as N, getIdentifierFromDid as O, type PricingModelArgs as P, type DidDocument as Q, ReputationModule as R, StakingModule as S, type VerificationMethod as T, type ServiceEndpoint as U, VerificationMethodType as V, type W3CVerifiableCredential as W, type DidResolutionMetadata as X, type W3CDidDocument as Y, type CreateDidDocumentParams as Z, type UpdateDidDocumentParams as _, GhostModule as a, type ResolveDidDocumentParams as a0, type ReputationData as a1, type PayAIReputationRecordInput as a2, type AgentWithAddress as a3, type AgentRegistrationData as a4, type AgentAccount as a5, PricingModel as a6, GhostSpeakError as a7, type RegisterAgentParams as a8, type RpcResponse as a9, type RpcAccountInfo as aa, type RpcProgramAccount as ab, type RpcProgramAccountsResponse as ac, type RpcAccountInfoResponse as ad, type RpcMultipleAccountsResponse as ae, type TransactionResponse as af, type SimulatedTransactionResponse as ag, type SolanaRpcClient as ah, type EmergencyConfig as ai, type Commitment as aj, type RetryConfig as ak, type RpcApi as al, type RpcSubscriptionApi as am, type StakingAccount as an, type StakingConfig as ao, getAgentDecoder as ap, decodeAgent as aq, fetchAgent as ar, fetchMaybeAgent as as, getStakingAccountDecoder as at, getStakingConfigDecoder as au, type Agent as av, GovernanceModule as b, AccessTier as c, GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS as d, type CacheConfig as e, type ClaimGhostParams as f, type PreparedClaimResult as g, type CreateProposalParams as h, type ProposalType as i, type ExecutionParams as j, CredentialModule as k, CredentialKind as l, CredentialStatus as m, type Credential as n, type CredentialTemplate as o, VerificationRelationship as p, ServiceEndpointType as q, DidError as r, DidErrorClass as s, deriveDidDocumentPda as t, generateDidString as u, validateDidString as v, parseDidString as w, exportAsW3CDidDocument as x, createEd25519VerificationMethod as y, createServiceEndpoint as z };