import { P as PrivacyMode, R as ReputationTier, S as ScoreRange, a as PrivacySettings, M as MetricVisibility, V as VisibleReputation } from './GhostSpeakClient-qdLGyuDp.js';
export { j as ApplyPresetParams, A as AuthorizationModule, G as GhostSpeakClient, h as GrantAccessParams, I as InitializePrivacyParams, n as IssuedCredentialResult, e as PRIVACY_CONSTANTS, b as PrivacyModule, f as PrivacyPreset, d as PrivacyPresets, i as RevokeAccessParams, g as SetMetricVisibilityParams, m as UnifiedCredentialConfig, k as UnifiedCredentialService, U as UpdatePrivacyModeParams, c as VisibilityLevel, G as default, l as lamportsToSol, s as sol } from './GhostSpeakClient-qdLGyuDp.js';
import { Address, ReadonlyUint8Array, Option, Decoder, TransactionSigner, AccountMeta, Instruction, InstructionWithData, InstructionWithAccounts, WritableAccount, ReadonlySignerAccount, AccountSignerMeta, ReadonlyAccount, OptionOrNullable, WritableSignerAccount, Slot, Lamports, Epoch, Base58EncodedBytes, Base64EncodedBytes, TransactionError, Base64EncodedWireTransaction, Signature, TransactionMessageBytesBase64, Commitment as Commitment$1, KeyPairSigner } from '@solana/kit';
export { TransactionSigner, address, createKeyPairSignerFromBytes, createSolanaRpc, generateKeyPairSigner } from '@solana/kit';
export { AddressOf, Agent, AgentCreationParams, AgentEvent, AgentMetadata, AgentType, Attachment, Channel, ChannelCreationParams, ChannelEvent, ChannelType, CommunicationMessage, CommunicationSession, ConfidentialBalance, ConfidentialTransfer, CreateCommunicationSessionParams, DeepPartial, ErrorCode, Escrow, EscrowCreationParams, EscrowEvent, Event, FilterOptions, Message, MessageType, Milestone, PaginationOptions, ParticipantStatus, ParticipantType, QueryResult, Rating, Reaction, Reputation, Result, SDKError, SendCommunicationMessageParams, SimulationResult, Transaction, TransferProof, UpdateParticipantStatusParams, WithAddress, isError, isSuccess, unwrap } from './types.js';
export { AccountNotFoundError, ErrorFactory, ErrorHandler, InsufficientBalanceError, InvalidInputError, NetworkError, SimulationFailedError, TimeoutError, TransactionFailedError, ValidationError } from './errors.js';
import { c as AccessTier, d as GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, P as PricingModelArgs, E as ExtendedRpcApi, B as BaseModule } from './StakingModule-CPhp_ZY0.js';
export { a8 as AgentAccount, A as AgentModule, a7 as AgentRegistrationData, a6 as AgentWithAddress, e as CacheConfig, C as CacheManager, f as ClaimGhostParams, am as Commitment, a0 as CreateDidDocumentParams, j as CreateProposalParams, p as Credential, n as CredentialKind, m as CredentialModule, o as CredentialStatus, q as CredentialTemplate, a2 as DeactivateDidDocumentParams, X as DidDocument, t as DidError, u as DidErrorClass, D as DidModule, _ as DidResolutionMetadata, al as EmergencyConfig, l as ExecutionParams, a as GhostModule, G as GhostSpeakConfig, aa as GhostSpeakError, b as GovernanceModule, i as InitializeStakingConfigParams, I as InstructionBuilder, M as MultisigModule, N as Network, a5 as PayAIReputationRecordInput, g as PreparedClaimResult, a9 as PricingModel, k as ProposalType, ab as RegisterAgentParams, a4 as ReputationData, R as ReputationModule, a3 as ResolveDidDocumentParams, an as RetryConfig, ad as RpcAccountInfo, ag as RpcAccountInfoResponse, ao as RpcApi, ah as RpcMultipleAccountsResponse, ae as RpcProgramAccount, af as RpcProgramAccountsResponse, ac as RpcResponse, ap as RpcSubscriptionApi, Z as ServiceEndpoint, s as ServiceEndpointType, aj as SimulatedTransactionResponse, ak as SolanaRpcClient, h as StakeParams, aq as StakingAccount, ar as StakingConfig, S as StakingModule, ai as TransactionResponse, U as UnstakeParams, a1 as UpdateDidDocumentParams, Y as VerificationMethod, V as VerificationMethodType, r as VerificationRelationship, $ as W3CDidDocument, W as W3CVerifiableCredential, L as canPerformAction, F as createEd25519VerificationMethod, H as createServiceEndpoint, at as decodeAgent, v as deriveDidDocumentPda, O as didDocumentToJson, z as exportAsW3CDidDocument, au as fetchAgent, av as fetchMaybeAgent, w as generateDidString, as as getAgentDecoder, T as getIdentifierFromDid, K as getMethodsForRelationship, Q as getNetworkFromDid, aw as getStakingAccountDecoder, ax as getStakingConfigDecoder, J as isDidActive, y as parseDidString, x as validateDidString } from './StakingModule-CPhp_ZY0.js';
import * as gill from 'gill';
import { SolanaClient } from 'gill';
import { Address as Address$1 } from '@solana/addresses';
export { l as AuthorizationFilter, p as AuthorizationInvalidReason, q as AuthorizationMessage, n as AuthorizationMetadata, o as AuthorizationProof, u as AuthorizationRevocation, A as AuthorizationStatus, t as AuthorizationUsage, k as AuthorizationWithStatus, B as BatchAuthorizationVerification, C as CreateAuthorizationParams, R as ReputationAuthorization, m as SolanaNetwork, V as VerificationDetails, r as VerifyAuthorizationParams, c as createAuthorizationMessage, b as createSignedAuthorization, e as deserializeAuthorization, g as generateNonce, f as getAuthorizationId, h as isAuthorizationExhausted, i as isAuthorizationExpired, d as serializeAuthorization, a as signAuthorizationMessage, j as validateAuthorizationNetwork, v as verifyAuthorizationSignature } from './signature-verification-BDzoR1MG.js';
export { h as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, A as ATTESTATION_SEED, d as AttestationPDAResult, C as CREDENTIAL_SEED, e as CreateAttestationConfig, f as GHOSTSPEAK_PROGRAM_ID, c as GhostOwnershipAttestationData, G as GhostSpeakCredentialConfig, N as NATIVE_MINT_ADDRESS, S as SASAttestationHelper, a as SAS_PROGRAM_ID, b as SCHEMA_SEED, g as TOKEN_2022_PROGRAM_ADDRESS, T as TOKEN_PROGRAM_ADDRESS } from './browser-D1TpjbjZ.js';
import { I as IPFSClient, C as ClientEncryptionService } from './feature-flags-B1g0DCPe.js';
export { A as AccountInspectionResult, a5 as AssociatedTokenAccount, K as BatchDiagnosticReport, af as ClientEncryptionOptions, a7 as ConfidentialTransferConfig, J as DiagnosticReport, D as DiscriminatorValidationResult, ad as EncryptedData, ai as FeatureFlagManager, aj as FeatureFlags, G as GhostSpeakSDKError, a8 as InterestBearingConfig, L as LegacyAgentData, M as MigrationPlan, x as MigrationResult, ae as PrivateMetadata, R as ReputationTagEngine, _ as TokenExtension, T as TokenProgram, a6 as TransferFeeConfig, m as createDiscriminatorErrorMessage, c as createErrorContext, o as createMigrationPlan, q as createMigrationReport, d as deriveAssociatedTokenAddress, a9 as deriveMultisigPda, aa as deriveProposalPda, S as deriveSplTokenAssociatedTokenAddress, U as deriveToken2022AssociatedTokenAddress, a as detectTokenProgram, B as diagnoseAccountFromChain, F as diagnoseBatchFromChain, e as enhanceTransactionError, H as exportDiagnosticReport, Q as extractInstructionName, u as extractLegacyData, f as formatTokenAmount, ab as generateLocalPrivacyProof, W as getAllAssociatedTokenAddresses, V as getAssociatedTokenAccount, a3 as getConfidentialTransferConfig, ag as getFeatureFlags, a4 as getInterestBearingConfig, t as getMigrationInstructions, Y as getTokenProgramAddress, Z as getTokenProgramFromAddress, g as getTokenProgramType, a2 as getTransferFeeConfig, a0 as hasConfidentialTransferExtension, a1 as hasInterestBearingExtension, $ as hasTransferFeeExtension, n as inspectAccountData, ah as isFeatureEnabled, i as isToken2022Mint, O as logEnhancedError, p as parseTokenAmount, y as runAccountDiagnostics, z as runBatchDiagnostics, s as safeDecodeAgent, r as simulateMigration, v as validateAccountDiscriminator, X as validateAssociatedTokenAddress, P as validatePreconditions, ac as verifyLocalPrivacyProof, w as withEnhancedErrors, N as withEnhancedErrorsSync } from './feature-flags-B1g0DCPe.js';
import { Rpc, GetSignaturesForAddressApi, GetTransactionApi, GetAccountInfoApi } from '@solana/rpc';
import { I as IPFSConfig, g as IPFSUploadOptions, C as ContentStorageResult, m as IPFSContentMetadata, h as IPFSOperationResult, r as IPFSError } from './reputation-types-Yebf0Rm_.js';
export { B as BadgeType, t as BehaviorTag, A as BulkTagUpdateRequest, o as CategoryReputation, u as ComplianceTag, D as DEFAULT_TAG_DECAY, K as FlexibleContent, l as IPFSPinResult, H as IPFSProviderConfig, j as IPFSRetrievalOptions, k as IPFSRetrievalResult, i as IPFSUploadResult, J as JobPerformance, F as ProposalStatus, s as REPUTATION_CONSTANTS, a as ReputationCalculationResult, p as ReputationTier, S as SkillTag, v as TAG_CONSTANTS, q as TagCategory, w as TagConfidenceLevel, x as TagCriteria, T as TagDecayConfig, y as TagEvaluation, d as TagFilters, e as TagQueryResult, b as TagReputationMetrics, c as TagScoreType, z as TagUpdateRequest } from './reputation-types-Yebf0Rm_.js';
export { CrossmintClientOptions, CredentialType as CrossmintCredentialType, IssuedCredential as CrossmintIssuedCredential, CrossmintVCClient, GHOSTSPEAK_CREDENTIAL_TYPES } from './credentials.js';
export { ElGamalCiphertext, ElGamalKeypair, TransferProof as ElGamalTransferProof, WasmModule, WithdrawProof, decrypt, elgamal, encrypt, generateKeypair, generateTransferProof, generateWithdrawProof, isWasmAvailable, loadWasmModule, wasmBridge } from './crypto.js';
export { d as deriveAgentPda, b as deriveAgentVerificationPda, a as deriveUserRegistryPda, f as findProgramDerivedAddress } from './pda-Ce7VYg4T.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
 */

/** Arbitrator's final decision on disputed escrow */
type ArbitratorDecision = {
    __kind: "FavorClient";
    reason: string;
} | {
    __kind: "FavorAgent";
    reason: string;
} | {
    __kind: "Split";
    clientPercentage: number;
    reason: string;
};
type ArbitratorDecisionArgs = ArbitratorDecision;

/**
 * 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 DeliverySubmittedEvent = {
    escrowId: bigint;
    agent: Address;
    deliveryProof: string;
};

/**
 * 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 DisputeFiledEvent = {
    escrowId: bigint;
    client: Address;
    reason: string;
};

/**
 * 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 DisputeResolvedEvent = {
    escrowId: bigint;
    decision: ArbitratorDecision;
    arbitrator: Address;
};

/**
 * 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 EscrowCompletedEvent = {
    escrowId: bigint;
    agent: Address;
    amount: 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
 */

type EscrowCreatedEvent = {
    escrowId: bigint;
    client: Address;
    agent: Address;
    amount: bigint;
    deadline: 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
 */

/** Escrow lifecycle states */
declare enum EscrowStatus {
    Active = 0,
    Completed = 1,
    Disputed = 2,
    Cancelled = 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
 */

type GhostSlashedEvent = {
    agent: Address;
    amount: bigint;
    reason: SlashReason;
    newTier: AccessTier;
};

/**
 * 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 GhostStakedEvent = {
    agent: Address;
    amount: bigint;
    unlockAt: bigint;
    reputationBoostBps: number;
    tier: AccessTier;
    dailyApiCalls: number;
    votingPower: 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
 */

type GhostUnstakedEvent = {
    agent: Address;
    amount: 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
 */

type ReputationTagsUpdatedEvent = {
    agent: Address;
    totalTags: number;
    skillTagsCount: number;
    behaviorTagsCount: number;
    complianceTagsCount: number;
    tagScoresCount: number;
    timestamp: 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
 */

type ServiceEndpointArgs = {
    /** Service identifier (e.g., "agent-api") */
    id: string;
    /** Type of service */
    serviceType: ServiceEndpointTypeArgs;
    /** Service endpoint URI */
    serviceEndpoint: string;
    /** Optional description */
    description: string;
};

/**
 * 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
 */

/** Service endpoint type */
declare enum ServiceEndpointType {
    AIAgentService = 0,
    DIDCommMessaging = 1,
    CredentialRepository = 2,
    LinkedDomains = 3,
    Custom = 4
}
type ServiceEndpointTypeArgs = ServiceEndpointType;

/**
 * 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
 */

/** Reasons for slashing staked tokens */
declare enum SlashReason {
    Fraud = 0,
    DisputeLoss = 1,
    Custom = 2
}
type SlashReasonArgs = SlashReason;

/**
 * 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 TagDecayAppliedEvent = {
    agent: Address;
    tagsRemoved: number;
    remainingTags: number;
    timestamp: 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
 */

/** Tag score with confidence tracking */
type TagScore = {
    /** Tag name (e.g., "fast-responder", "defi-expert") */
    tagName: string;
    /** Confidence score in basis points (0-10000) */
    confidence: number;
    /** Number of supporting data points for this tag */
    evidenceCount: number;
    /** Last time this tag was updated */
    lastUpdated: bigint;
};
type TagScoreArgs = {
    /** Tag name (e.g., "fast-responder", "defi-expert") */
    tagName: string;
    /** Confidence score in basis points (0-10000) */
    confidence: number;
    /** Number of supporting data points for this tag */
    evidenceCount: number;
    /** Last time this tag was updated */
    lastUpdated: 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
 */

type VerificationMethodArgs = {
    /** Method identifier (e.g., "key-1") */
    id: string;
    /** Type of verification method */
    methodType: VerificationMethodTypeArgs;
    /** DID of the controller (usually the DID itself) */
    controller: string;
    /** Public key in multibase format (base58btc) */
    publicKeyMultibase: string;
    /** Verification relationships this key has */
    relationships: Array<VerificationRelationshipArgs>;
    /** Creation timestamp */
    createdAt: number | bigint;
    /** Revoked flag */
    revoked: boolean;
};

/**
 * 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
 */

/** Verification method type for DIDs */
declare enum VerificationMethodType {
    Ed25519VerificationKey2020 = 0,
    X25519KeyAgreementKey2020 = 1,
    EcdsaSecp256k1VerificationKey2019 = 2
}
type VerificationMethodTypeArgs = VerificationMethodType;

/**
 * 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
 */

/** Verification relationship types */
declare enum VerificationRelationship {
    Authentication = 0,
    AssertionMethod = 1,
    KeyAgreement = 2,
    CapabilityInvocation = 3,
    CapabilityDelegation = 4
}
type VerificationRelationshipArgs = VerificationRelationship;

/**
 * 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 GhostProtectEscrow = {
    discriminator: ReadonlyUint8Array;
    /** Unique escrow ID */
    escrowId: bigint;
    /** Client (payer) */
    client: Address;
    /** Agent (service provider) */
    agent: Address;
    /** Payment amount */
    amount: bigint;
    /** Payment token mint */
    tokenMint: Address;
    /** Escrow status */
    status: EscrowStatus;
    /** Job description (IPFS hash) */
    jobDescription: string;
    /** Delivery proof (IPFS hash) */
    deliveryProof: Option<string>;
    /** Deadline timestamp */
    deadline: bigint;
    /** Created timestamp */
    createdAt: bigint;
    /** Completed/disputed timestamp */
    completedAt: Option<bigint>;
    /** Dispute reason (if disputed) */
    disputeReason: Option<string>;
    /** Arbitrator decision (if disputed) */
    arbitratorDecision: Option<ArbitratorDecision>;
    bump: number;
};
/** Gets the decoder for {@link GhostProtectEscrow} account data. */
declare function getGhostProtectEscrowDecoder(): Decoder<GhostProtectEscrow>;

/**
 * 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 ApproveDeliveryInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountEscrow extends string | AccountMeta<string> = string, TAccountEscrowVault extends string | AccountMeta<string> = string, TAccountAgentTokenAccount extends string | AccountMeta<string> = string, TAccountClient extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
    TAccountEscrowVault extends string ? WritableAccount<TAccountEscrowVault> : TAccountEscrowVault,
    TAccountAgentTokenAccount extends string ? WritableAccount<TAccountAgentTokenAccount> : TAccountAgentTokenAccount,
    TAccountClient extends string ? ReadonlySignerAccount<TAccountClient> & AccountSignerMeta<TAccountClient> : TAccountClient,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    ...TRemainingAccounts
]>;
type ApproveDeliveryInput<TAccountEscrow extends string = string, TAccountEscrowVault extends string = string, TAccountAgentTokenAccount extends string = string, TAccountClient extends string = string, TAccountTokenProgram extends string = string> = {
    escrow: Address<TAccountEscrow>;
    escrowVault: Address<TAccountEscrowVault>;
    agentTokenAccount: Address<TAccountAgentTokenAccount>;
    client: TransactionSigner<TAccountClient>;
    tokenProgram?: Address<TAccountTokenProgram>;
};
declare function getApproveDeliveryInstruction<TAccountEscrow extends string, TAccountEscrowVault extends string, TAccountAgentTokenAccount extends string, TAccountClient extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: ApproveDeliveryInput<TAccountEscrow, TAccountEscrowVault, TAccountAgentTokenAccount, TAccountClient, TAccountTokenProgram>, config?: {
    programAddress?: TProgramAddress;
}): ApproveDeliveryInstruction<TProgramAddress, TAccountEscrow, TAccountEscrowVault, TAccountAgentTokenAccount, TAccountClient, TAccountTokenProgram>;

/**
 * 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 ArbitrateDisputeInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountEscrow extends string | AccountMeta<string> = string, TAccountEscrowVault extends string | AccountMeta<string> = string, TAccountAgentTokenAccount extends string | AccountMeta<string> = string, TAccountClientTokenAccount extends string | AccountMeta<string> = string, TAccountAgentStaking extends string | AccountMeta<string> = string, TAccountArbitrator extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
    TAccountEscrowVault extends string ? WritableAccount<TAccountEscrowVault> : TAccountEscrowVault,
    TAccountAgentTokenAccount extends string ? WritableAccount<TAccountAgentTokenAccount> : TAccountAgentTokenAccount,
    TAccountClientTokenAccount extends string ? WritableAccount<TAccountClientTokenAccount> : TAccountClientTokenAccount,
    TAccountAgentStaking extends string ? WritableAccount<TAccountAgentStaking> : TAccountAgentStaking,
    TAccountArbitrator extends string ? ReadonlySignerAccount<TAccountArbitrator> & AccountSignerMeta<TAccountArbitrator> : TAccountArbitrator,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    ...TRemainingAccounts
]>;
type ArbitrateDisputeInstructionDataArgs = {
    decision: ArbitratorDecisionArgs;
};
type ArbitrateDisputeInput<TAccountEscrow extends string = string, TAccountEscrowVault extends string = string, TAccountAgentTokenAccount extends string = string, TAccountClientTokenAccount extends string = string, TAccountAgentStaking extends string = string, TAccountArbitrator extends string = string, TAccountTokenProgram extends string = string> = {
    escrow: Address<TAccountEscrow>;
    escrowVault: Address<TAccountEscrowVault>;
    agentTokenAccount: Address<TAccountAgentTokenAccount>;
    clientTokenAccount: Address<TAccountClientTokenAccount>;
    /** Agent's staking account (for potential slashing) */
    agentStaking: Address<TAccountAgentStaking>;
    arbitrator: TransactionSigner<TAccountArbitrator>;
    tokenProgram?: Address<TAccountTokenProgram>;
    decision: ArbitrateDisputeInstructionDataArgs["decision"];
};
declare function getArbitrateDisputeInstruction<TAccountEscrow extends string, TAccountEscrowVault extends string, TAccountAgentTokenAccount extends string, TAccountClientTokenAccount extends string, TAccountAgentStaking extends string, TAccountArbitrator extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: ArbitrateDisputeInput<TAccountEscrow, TAccountEscrowVault, TAccountAgentTokenAccount, TAccountClientTokenAccount, TAccountAgentStaking, TAccountArbitrator, TAccountTokenProgram>, config?: {
    programAddress?: TProgramAddress;
}): ArbitrateDisputeInstruction<TProgramAddress, TAccountEscrow, TAccountEscrowVault, TAccountAgentTokenAccount, TAccountClientTokenAccount, TAccountAgentStaking, TAccountArbitrator, TAccountTokenProgram>;

/**
 * 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 ClaimGhostInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountAgentAccount extends string | AccountMeta<string> = string, TAccountDidDocument extends string | AccountMeta<string> = string, TAccountSasAttestation extends string | AccountMeta<string> = string, TAccountClaimer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountAgentAccount extends string ? WritableAccount<TAccountAgentAccount> : TAccountAgentAccount,
    TAccountDidDocument extends string ? WritableAccount<TAccountDidDocument> : TAccountDidDocument,
    TAccountSasAttestation extends string ? ReadonlyAccount<TAccountSasAttestation> : TAccountSasAttestation,
    TAccountClaimer extends string ? WritableSignerAccount<TAccountClaimer> & AccountSignerMeta<TAccountClaimer> : TAccountClaimer,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    ...TRemainingAccounts
]>;
type ClaimGhostInstructionDataArgs = {
    sasCredential: Address;
    sasSchema: Address;
    ipfsMetadataUri: OptionOrNullable<string>;
    network: string;
};
type ClaimGhostInput<TAccountAgentAccount extends string = string, TAccountDidDocument extends string = string, TAccountSasAttestation extends string = string, TAccountClaimer extends string = string, TAccountSystemProgram extends string = string> = {
    agentAccount: Address<TAccountAgentAccount>;
    /**
     * DID document to create for this Ghost
     * Seeds: [b"did_document", agent_account.x402_payment_address.as_ref()]
     */
    didDocument: Address<TAccountDidDocument>;
    /**
     * SAS Attestation proving ownership of x402_payment_address
     * PDA: [b"attestation", sas_credential, sas_schema, x402_payment_address]
     */
    sasAttestation: Address<TAccountSasAttestation>;
    /** The claimer must have created a SAS attestation proving they own x402_payment_address */
    claimer: TransactionSigner<TAccountClaimer>;
    systemProgram?: Address<TAccountSystemProgram>;
    sasCredential: ClaimGhostInstructionDataArgs["sasCredential"];
    sasSchema: ClaimGhostInstructionDataArgs["sasSchema"];
    ipfsMetadataUri: ClaimGhostInstructionDataArgs["ipfsMetadataUri"];
    network: ClaimGhostInstructionDataArgs["network"];
};
declare function getClaimGhostInstruction<TAccountAgentAccount extends string, TAccountDidDocument extends string, TAccountSasAttestation extends string, TAccountClaimer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: ClaimGhostInput<TAccountAgentAccount, TAccountDidDocument, TAccountSasAttestation, TAccountClaimer, TAccountSystemProgram>, config?: {
    programAddress?: TProgramAddress;
}): ClaimGhostInstruction<TProgramAddress, TAccountAgentAccount, TAccountDidDocument, TAccountSasAttestation, TAccountClaimer, TAccountSystemProgram>;

/**
 * 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 CreateDidDocumentInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountDidDocument extends string | AccountMeta<string> = string, TAccountController extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TAccountClock extends string | AccountMeta<string> = "SysvarC1ock11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountDidDocument extends string ? WritableAccount<TAccountDidDocument> : TAccountDidDocument,
    TAccountController extends string ? WritableSignerAccount<TAccountController> & AccountSignerMeta<TAccountController> : TAccountController,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    TAccountClock extends string ? ReadonlyAccount<TAccountClock> : TAccountClock,
    ...TRemainingAccounts
]>;
type CreateDidDocumentInstructionDataArgs = {
    didString: string;
    verificationMethods: Array<VerificationMethodArgs>;
    serviceEndpoints: Array<ServiceEndpointArgs>;
};
type CreateDidDocumentAsyncInput<TAccountDidDocument extends string = string, TAccountController extends string = string, TAccountSystemProgram extends string = string, TAccountClock extends string = string> = {
    /** DID document account with canonical PDA */
    didDocument?: Address<TAccountDidDocument>;
    /** Controller of the DID (owner) */
    controller: TransactionSigner<TAccountController>;
    /** System program for account creation */
    systemProgram?: Address<TAccountSystemProgram>;
    /** Clock sysvar for timestamp validation */
    clock?: Address<TAccountClock>;
    didString: CreateDidDocumentInstructionDataArgs["didString"];
    verificationMethods: CreateDidDocumentInstructionDataArgs["verificationMethods"];
    serviceEndpoints: CreateDidDocumentInstructionDataArgs["serviceEndpoints"];
};
declare function getCreateDidDocumentInstructionAsync<TAccountDidDocument extends string, TAccountController extends string, TAccountSystemProgram extends string, TAccountClock extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: CreateDidDocumentAsyncInput<TAccountDidDocument, TAccountController, TAccountSystemProgram, TAccountClock>, config?: {
    programAddress?: TProgramAddress;
}): Promise<CreateDidDocumentInstruction<TProgramAddress, TAccountDidDocument, TAccountController, TAccountSystemProgram, TAccountClock>>;

/**
 * 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 CreateEscrowInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountEscrow extends string | AccountMeta<string> = string, TAccountAgent extends string | AccountMeta<string> = string, TAccountClientTokenAccount extends string | AccountMeta<string> = string, TAccountEscrowVault extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountClient extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
    TAccountAgent extends string ? ReadonlyAccount<TAccountAgent> : TAccountAgent,
    TAccountClientTokenAccount extends string ? WritableAccount<TAccountClientTokenAccount> : TAccountClientTokenAccount,
    TAccountEscrowVault extends string ? WritableAccount<TAccountEscrowVault> : TAccountEscrowVault,
    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
    TAccountClient extends string ? WritableSignerAccount<TAccountClient> & AccountSignerMeta<TAccountClient> : TAccountClient,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    ...TRemainingAccounts
]>;
type CreateEscrowInstructionDataArgs = {
    escrowId: number | bigint;
    amount: number | bigint;
    jobDescription: string;
    deadline: number | bigint;
};
type CreateEscrowAsyncInput<TAccountEscrow extends string = string, TAccountAgent extends string = string, TAccountClientTokenAccount extends string = string, TAccountEscrowVault extends string = string, TAccountTokenMint extends string = string, TAccountClient extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
    escrow?: Address<TAccountEscrow>;
    agent: Address<TAccountAgent>;
    clientTokenAccount: Address<TAccountClientTokenAccount>;
    escrowVault: Address<TAccountEscrowVault>;
    tokenMint: Address<TAccountTokenMint>;
    client: TransactionSigner<TAccountClient>;
    tokenProgram?: Address<TAccountTokenProgram>;
    systemProgram?: Address<TAccountSystemProgram>;
    escrowId: CreateEscrowInstructionDataArgs["escrowId"];
    amount: CreateEscrowInstructionDataArgs["amount"];
    jobDescription: CreateEscrowInstructionDataArgs["jobDescription"];
    deadline: CreateEscrowInstructionDataArgs["deadline"];
};
declare function getCreateEscrowInstructionAsync<TAccountEscrow extends string, TAccountAgent extends string, TAccountClientTokenAccount extends string, TAccountEscrowVault extends string, TAccountTokenMint extends string, TAccountClient extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: CreateEscrowAsyncInput<TAccountEscrow, TAccountAgent, TAccountClientTokenAccount, TAccountEscrowVault, TAccountTokenMint, TAccountClient, TAccountTokenProgram, TAccountSystemProgram>, config?: {
    programAddress?: TProgramAddress;
}): Promise<CreateEscrowInstruction<TProgramAddress, TAccountEscrow, TAccountAgent, TAccountClientTokenAccount, TAccountEscrowVault, TAccountTokenMint, TAccountClient, TAccountTokenProgram, TAccountSystemProgram>>;

/**
 * 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 DeactivateDidDocumentInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountDidDocument extends string | AccountMeta<string> = string, TAccountController extends string | AccountMeta<string> = string, TAccountClock extends string | AccountMeta<string> = "SysvarC1ock11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountDidDocument extends string ? WritableAccount<TAccountDidDocument> : TAccountDidDocument,
    TAccountController extends string ? WritableSignerAccount<TAccountController> & AccountSignerMeta<TAccountController> : TAccountController,
    TAccountClock extends string ? ReadonlyAccount<TAccountClock> : TAccountClock,
    ...TRemainingAccounts
]>;
type DeactivateDidDocumentAsyncInput<TAccountDidDocument extends string = string, TAccountController extends string = string, TAccountClock extends string = string> = {
    /** DID document account with canonical PDA validation */
    didDocument?: Address<TAccountDidDocument>;
    /** Controller of the DID (must match document controller) */
    controller: TransactionSigner<TAccountController>;
    /** Clock sysvar for timestamp validation */
    clock?: Address<TAccountClock>;
};
declare function getDeactivateDidDocumentInstructionAsync<TAccountDidDocument extends string, TAccountController extends string, TAccountClock extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: DeactivateDidDocumentAsyncInput<TAccountDidDocument, TAccountController, TAccountClock>, config?: {
    programAddress?: TProgramAddress;
}): Promise<DeactivateDidDocumentInstruction<TProgramAddress, TAccountDidDocument, TAccountController, TAccountClock>>;

/**
 * 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 FileDisputeInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountEscrow extends string | AccountMeta<string> = string, TAccountClient extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
    TAccountClient extends string ? ReadonlySignerAccount<TAccountClient> & AccountSignerMeta<TAccountClient> : TAccountClient,
    ...TRemainingAccounts
]>;
type FileDisputeInstructionDataArgs = {
    reason: string;
};
type FileDisputeInput<TAccountEscrow extends string = string, TAccountClient extends string = string> = {
    escrow: Address<TAccountEscrow>;
    client: TransactionSigner<TAccountClient>;
    reason: FileDisputeInstructionDataArgs["reason"];
};
declare function getFileDisputeInstruction<TAccountEscrow extends string, TAccountClient extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: FileDisputeInput<TAccountEscrow, TAccountClient>, config?: {
    programAddress?: TProgramAddress;
}): FileDisputeInstruction<TProgramAddress, TAccountEscrow, TAccountClient>;

/**
 * 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 InitializeStakingConfigInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountStakingConfig extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountStakingConfig extends string ? WritableAccount<TAccountStakingConfig> : TAccountStakingConfig,
    TAccountAuthority extends string ? WritableSignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    ...TRemainingAccounts
]>;
type InitializeStakingConfigInstructionDataArgs = {
    minStake: number | bigint;
    treasury: Address;
};
type InitializeStakingConfigAsyncInput<TAccountStakingConfig extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> = {
    stakingConfig?: Address<TAccountStakingConfig>;
    authority: TransactionSigner<TAccountAuthority>;
    systemProgram?: Address<TAccountSystemProgram>;
    minStake: InitializeStakingConfigInstructionDataArgs["minStake"];
    treasury: InitializeStakingConfigInstructionDataArgs["treasury"];
};
declare function getInitializeStakingConfigInstructionAsync<TAccountStakingConfig extends string, TAccountAuthority extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: InitializeStakingConfigAsyncInput<TAccountStakingConfig, TAccountAuthority, TAccountSystemProgram>, config?: {
    programAddress?: TProgramAddress;
}): Promise<InitializeStakingConfigInstruction<TProgramAddress, TAccountStakingConfig, TAccountAuthority, TAccountSystemProgram>>;

/**
 * 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 RegisterAgentInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountAgentAccount extends string | AccountMeta<string> = string, TAccountStakingAccount extends string | AccountMeta<string> = string, TAccountSigner extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TAccountClock extends string | AccountMeta<string> = "SysvarC1ock11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountAgentAccount extends string ? WritableAccount<TAccountAgentAccount> : TAccountAgentAccount,
    TAccountStakingAccount extends string ? ReadonlyAccount<TAccountStakingAccount> : TAccountStakingAccount,
    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    TAccountClock extends string ? ReadonlyAccount<TAccountClock> : TAccountClock,
    ...TRemainingAccounts
]>;
type RegisterAgentInstructionDataArgs = {
    agentType: number;
    name: string;
    description: string;
    metadataUri: string;
    agentId: string;
    pricingModel: PricingModelArgs;
};
type RegisterAgentAsyncInput<TAccountAgentAccount extends string = string, TAccountStakingAccount extends string = string, TAccountSigner extends string = string, TAccountSystemProgram extends string = string, TAccountClock extends string = string> = {
    /** Agent account with enhanced 2025 PDA security */
    agentAccount?: Address<TAccountAgentAccount>;
    /** Staking account - REQUIRED for Sybil resistance (must have >= 1K GHOST staked) */
    stakingAccount?: Address<TAccountStakingAccount>;
    /**
     * User registry with enhanced validation
     * Authority with enhanced verification
     */
    signer: TransactionSigner<TAccountSigner>;
    /** System program for account creation */
    systemProgram?: Address<TAccountSystemProgram>;
    /** Clock sysvar for timestamp validation */
    clock?: Address<TAccountClock>;
    agentType: RegisterAgentInstructionDataArgs["agentType"];
    name: RegisterAgentInstructionDataArgs["name"];
    description: RegisterAgentInstructionDataArgs["description"];
    metadataUri: RegisterAgentInstructionDataArgs["metadataUri"];
    agentId: RegisterAgentInstructionDataArgs["agentId"];
    pricingModel: RegisterAgentInstructionDataArgs["pricingModel"];
};
declare function getRegisterAgentInstructionAsync<TAccountAgentAccount extends string, TAccountStakingAccount extends string, TAccountSigner extends string, TAccountSystemProgram extends string, TAccountClock extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: RegisterAgentAsyncInput<TAccountAgentAccount, TAccountStakingAccount, TAccountSigner, TAccountSystemProgram, TAccountClock>, config?: {
    programAddress?: TProgramAddress;
}): Promise<RegisterAgentInstruction<TProgramAddress, TAccountAgentAccount, TAccountStakingAccount, TAccountSigner, TAccountSystemProgram, TAccountClock>>;

/**
 * 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 ResolveDidDocumentInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountDidDocument extends string | AccountMeta<string> = string, TAccountDidController extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountDidDocument extends string ? ReadonlyAccount<TAccountDidDocument> : TAccountDidDocument,
    TAccountDidController extends string ? ReadonlyAccount<TAccountDidController> : TAccountDidController,
    ...TRemainingAccounts
]>;
type ResolveDidDocumentAsyncInput<TAccountDidDocument extends string = string, TAccountDidController extends string = string> = {
    /** DID document account */
    didDocument?: Address<TAccountDidDocument>;
    /** Controller public key (used for PDA derivation) */
    didController: Address<TAccountDidController>;
};
declare function getResolveDidDocumentInstructionAsync<TAccountDidDocument extends string, TAccountDidController extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: ResolveDidDocumentAsyncInput<TAccountDidDocument, TAccountDidController>, config?: {
    programAddress?: TProgramAddress;
}): Promise<ResolveDidDocumentInstruction<TProgramAddress, TAccountDidDocument, TAccountDidController>>;

/**
 * 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 SlashStakeInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountStakingAccount extends string | AccountMeta<string> = string, TAccountStakingConfig extends string | AccountMeta<string> = string, TAccountStakingVault extends string | AccountMeta<string> = string, TAccountTreasury extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountStakingAccount extends string ? WritableAccount<TAccountStakingAccount> : TAccountStakingAccount,
    TAccountStakingConfig extends string ? ReadonlyAccount<TAccountStakingConfig> : TAccountStakingConfig,
    TAccountStakingVault extends string ? WritableAccount<TAccountStakingVault> : TAccountStakingVault,
    TAccountTreasury extends string ? WritableAccount<TAccountTreasury> : TAccountTreasury,
    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    ...TRemainingAccounts
]>;
type SlashStakeInstructionDataArgs = {
    owner: Address;
    reason: SlashReasonArgs;
    customAmount: OptionOrNullable<number | bigint>;
};
type SlashStakeAsyncInput<TAccountStakingAccount extends string = string, TAccountStakingConfig extends string = string, TAccountStakingVault extends string = string, TAccountTreasury extends string = string, TAccountAuthority extends string = string, TAccountTokenProgram extends string = string> = {
    stakingAccount?: Address<TAccountStakingAccount>;
    stakingConfig?: Address<TAccountStakingConfig>;
    stakingVault?: Address<TAccountStakingVault>;
    treasury: Address<TAccountTreasury>;
    authority: TransactionSigner<TAccountAuthority>;
    tokenProgram?: Address<TAccountTokenProgram>;
    owner: SlashStakeInstructionDataArgs["owner"];
    reason: SlashStakeInstructionDataArgs["reason"];
    customAmount: SlashStakeInstructionDataArgs["customAmount"];
};
declare function getSlashStakeInstructionAsync<TAccountStakingAccount extends string, TAccountStakingConfig extends string, TAccountStakingVault extends string, TAccountTreasury extends string, TAccountAuthority extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: SlashStakeAsyncInput<TAccountStakingAccount, TAccountStakingConfig, TAccountStakingVault, TAccountTreasury, TAccountAuthority, TAccountTokenProgram>, config?: {
    programAddress?: TProgramAddress;
}): Promise<SlashStakeInstruction<TProgramAddress, TAccountStakingAccount, TAccountStakingConfig, TAccountStakingVault, TAccountTreasury, TAccountAuthority, TAccountTokenProgram>>;

/**
 * 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 StakeGhostInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountStakingAccount extends string | AccountMeta<string> = string, TAccountOwnerTokenAccount extends string | AccountMeta<string> = string, TAccountStakingVault extends string | AccountMeta<string> = string, TAccountStakingConfig extends string | AccountMeta<string> = string, TAccountGhostMint extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TAccountRent extends string | AccountMeta<string> = "SysvarRent111111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountStakingAccount extends string ? WritableAccount<TAccountStakingAccount> : TAccountStakingAccount,
    TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
    TAccountStakingVault extends string ? WritableAccount<TAccountStakingVault> : TAccountStakingVault,
    TAccountStakingConfig extends string ? ReadonlyAccount<TAccountStakingConfig> : TAccountStakingConfig,
    TAccountGhostMint extends string ? ReadonlyAccount<TAccountGhostMint> : TAccountGhostMint,
    TAccountOwner extends string ? WritableSignerAccount<TAccountOwner> & AccountSignerMeta<TAccountOwner> : TAccountOwner,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
    TAccountRent extends string ? ReadonlyAccount<TAccountRent> : TAccountRent,
    ...TRemainingAccounts
]>;
type StakeGhostInstructionDataArgs = {
    amount: number | bigint;
    lockDuration: number | bigint;
};
type StakeGhostAsyncInput<TAccountStakingAccount extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountStakingVault extends string = string, TAccountStakingConfig extends string = string, TAccountGhostMint extends string = string, TAccountOwner extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string> = {
    stakingAccount?: Address<TAccountStakingAccount>;
    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
    /**
     * Staking vault to hold all staked GHOST tokens
     * Automatically initialized on first stake using init_if_needed
     */
    stakingVault?: Address<TAccountStakingVault>;
    stakingConfig: Address<TAccountStakingConfig>;
    ghostMint: Address<TAccountGhostMint>;
    owner: TransactionSigner<TAccountOwner>;
    tokenProgram?: Address<TAccountTokenProgram>;
    systemProgram?: Address<TAccountSystemProgram>;
    rent?: Address<TAccountRent>;
    amount: StakeGhostInstructionDataArgs["amount"];
    lockDuration: StakeGhostInstructionDataArgs["lockDuration"];
};
declare function getStakeGhostInstructionAsync<TAccountStakingAccount extends string, TAccountOwnerTokenAccount extends string, TAccountStakingVault extends string, TAccountStakingConfig extends string, TAccountGhostMint extends string, TAccountOwner extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TAccountRent extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: StakeGhostAsyncInput<TAccountStakingAccount, TAccountOwnerTokenAccount, TAccountStakingVault, TAccountStakingConfig, TAccountGhostMint, TAccountOwner, TAccountTokenProgram, TAccountSystemProgram, TAccountRent>, config?: {
    programAddress?: TProgramAddress;
}): Promise<StakeGhostInstruction<TProgramAddress, TAccountStakingAccount, TAccountOwnerTokenAccount, TAccountStakingVault, TAccountStakingConfig, TAccountGhostMint, TAccountOwner, TAccountTokenProgram, TAccountSystemProgram, TAccountRent>>;

/**
 * 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 SubmitDeliveryInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountEscrow extends string | AccountMeta<string> = string, TAccountAgent extends string | AccountMeta<string> = string, TAccountAgentOwner extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
    TAccountAgent extends string ? ReadonlyAccount<TAccountAgent> : TAccountAgent,
    TAccountAgentOwner extends string ? ReadonlySignerAccount<TAccountAgentOwner> & AccountSignerMeta<TAccountAgentOwner> : TAccountAgentOwner,
    ...TRemainingAccounts
]>;
type SubmitDeliveryInstructionDataArgs = {
    deliveryProof: string;
};
type SubmitDeliveryInput<TAccountEscrow extends string = string, TAccountAgent extends string = string, TAccountAgentOwner extends string = string> = {
    escrow: Address<TAccountEscrow>;
    agent: Address<TAccountAgent>;
    agentOwner: TransactionSigner<TAccountAgentOwner>;
    deliveryProof: SubmitDeliveryInstructionDataArgs["deliveryProof"];
};
declare function getSubmitDeliveryInstruction<TAccountEscrow extends string, TAccountAgent extends string, TAccountAgentOwner extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: SubmitDeliveryInput<TAccountEscrow, TAccountAgent, TAccountAgentOwner>, config?: {
    programAddress?: TProgramAddress;
}): SubmitDeliveryInstruction<TProgramAddress, TAccountEscrow, TAccountAgent, TAccountAgentOwner>;

/**
 * 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 UnstakeGhostInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountStakingAccount extends string | AccountMeta<string> = string, TAccountStakingConfig extends string | AccountMeta<string> = string, TAccountStakingVault extends string | AccountMeta<string> = string, TAccountOwnerTokenAccount extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountStakingAccount extends string ? WritableAccount<TAccountStakingAccount> : TAccountStakingAccount,
    TAccountStakingConfig extends string ? ReadonlyAccount<TAccountStakingConfig> : TAccountStakingConfig,
    TAccountStakingVault extends string ? WritableAccount<TAccountStakingVault> : TAccountStakingVault,
    TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
    TAccountOwner extends string ? WritableSignerAccount<TAccountOwner> & AccountSignerMeta<TAccountOwner> : TAccountOwner,
    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
    ...TRemainingAccounts
]>;
type UnstakeGhostAsyncInput<TAccountStakingAccount extends string = string, TAccountStakingConfig extends string = string, TAccountStakingVault extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountOwner extends string = string, TAccountTokenProgram extends string = string> = {
    stakingAccount?: Address<TAccountStakingAccount>;
    stakingConfig?: Address<TAccountStakingConfig>;
    stakingVault?: Address<TAccountStakingVault>;
    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
    owner: TransactionSigner<TAccountOwner>;
    tokenProgram?: Address<TAccountTokenProgram>;
};
declare function getUnstakeGhostInstructionAsync<TAccountStakingAccount extends string, TAccountStakingConfig extends string, TAccountStakingVault extends string, TAccountOwnerTokenAccount extends string, TAccountOwner extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: UnstakeGhostAsyncInput<TAccountStakingAccount, TAccountStakingConfig, TAccountStakingVault, TAccountOwnerTokenAccount, TAccountOwner, TAccountTokenProgram>, config?: {
    programAddress?: TProgramAddress;
}): Promise<UnstakeGhostInstruction<TProgramAddress, TAccountStakingAccount, TAccountStakingConfig, TAccountStakingVault, TAccountOwnerTokenAccount, TAccountOwner, TAccountTokenProgram>>;

/**
 * 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 UpdateDidDocumentInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountDidDocument extends string | AccountMeta<string> = string, TAccountController extends string | AccountMeta<string> = string, TAccountClock extends string | AccountMeta<string> = "SysvarC1ock11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountDidDocument extends string ? WritableAccount<TAccountDidDocument> : TAccountDidDocument,
    TAccountController extends string ? WritableSignerAccount<TAccountController> & AccountSignerMeta<TAccountController> : TAccountController,
    TAccountClock extends string ? ReadonlyAccount<TAccountClock> : TAccountClock,
    ...TRemainingAccounts
]>;
type UpdateDidDocumentInstructionDataArgs = {
    addVerificationMethod: OptionOrNullable<VerificationMethodArgs>;
    removeVerificationMethodId: OptionOrNullable<string>;
    addServiceEndpoint: OptionOrNullable<ServiceEndpointArgs>;
    removeServiceEndpointId: OptionOrNullable<string>;
};
type UpdateDidDocumentAsyncInput<TAccountDidDocument extends string = string, TAccountController extends string = string, TAccountClock extends string = string> = {
    /** DID document account with canonical PDA validation */
    didDocument?: Address<TAccountDidDocument>;
    /** Controller of the DID (must match document controller) */
    controller: TransactionSigner<TAccountController>;
    /** Clock sysvar for timestamp validation */
    clock?: Address<TAccountClock>;
    addVerificationMethod: UpdateDidDocumentInstructionDataArgs["addVerificationMethod"];
    removeVerificationMethodId: UpdateDidDocumentInstructionDataArgs["removeVerificationMethodId"];
    addServiceEndpoint: UpdateDidDocumentInstructionDataArgs["addServiceEndpoint"];
    removeServiceEndpointId: UpdateDidDocumentInstructionDataArgs["removeServiceEndpointId"];
};
declare function getUpdateDidDocumentInstructionAsync<TAccountDidDocument extends string, TAccountController extends string, TAccountClock extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: UpdateDidDocumentAsyncInput<TAccountDidDocument, TAccountController, TAccountClock>, config?: {
    programAddress?: TProgramAddress;
}): Promise<UpdateDidDocumentInstruction<TProgramAddress, TAccountDidDocument, TAccountController, TAccountClock>>;

/**
 * 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 UpdateReputationTagsInstruction<TProgram extends string = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, TAccountReputationMetrics extends string | AccountMeta<string> = string, TAccountAgent extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountClock extends string | AccountMeta<string> = "SysvarC1ock11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
    TAccountReputationMetrics extends string ? WritableAccount<TAccountReputationMetrics> : TAccountReputationMetrics,
    TAccountAgent extends string ? WritableAccount<TAccountAgent> : TAccountAgent,
    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
    TAccountClock extends string ? ReadonlyAccount<TAccountClock> : TAccountClock,
    ...TRemainingAccounts
]>;
type UpdateReputationTagsInstructionDataArgs = {
    skillTags: Array<string>;
    behaviorTags: Array<string>;
    complianceTags: Array<string>;
    tagScores: Array<TagScoreArgs>;
};
type UpdateReputationTagsAsyncInput<TAccountReputationMetrics extends string = string, TAccountAgent extends string = string, TAccountAuthority extends string = string, TAccountClock extends string = string> = {
    /** Reputation metrics account */
    reputationMetrics?: Address<TAccountReputationMetrics>;
    /** Agent account */
    agent: Address<TAccountAgent>;
    /** Authority (can be the agent owner or authorized updater) */
    authority: TransactionSigner<TAccountAuthority>;
    /** Clock for timestamps */
    clock?: Address<TAccountClock>;
    skillTags: UpdateReputationTagsInstructionDataArgs["skillTags"];
    behaviorTags: UpdateReputationTagsInstructionDataArgs["behaviorTags"];
    complianceTags: UpdateReputationTagsInstructionDataArgs["complianceTags"];
    tagScores: UpdateReputationTagsInstructionDataArgs["tagScores"];
};
declare function getUpdateReputationTagsInstructionAsync<TAccountReputationMetrics extends string, TAccountAgent extends string, TAccountAuthority extends string, TAccountClock extends string, TProgramAddress extends Address = typeof GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS>(input: UpdateReputationTagsAsyncInput<TAccountReputationMetrics, TAccountAgent, TAccountAuthority, TAccountClock>, config?: {
    programAddress?: TProgramAddress;
}): Promise<UpdateReputationTagsInstruction<TProgramAddress, TAccountReputationMetrics, TAccountAgent, TAccountAuthority, TAccountClock>>;

/**
 * RPC Type Definitions for Solana Web3.js v2
 * July 2025 Best Practices
 *
 * These types leverage TypeScript's advanced features for type safety
 * and use modern patterns from @solana/web3.js v2
 */

type Commitment = 'processed' | 'confirmed' | 'finalized';
interface AccountInfo$2<TData = Buffer | ParsedAccountData> {
    /** Indicates if the account contains a program */
    executable: boolean;
    /** Number of lamports in the account */
    lamports: Lamports;
    /** Public key of the program this account has been assigned to */
    owner: Address;
    /** Epoch at which this account will next owe rent */
    rentEpoch: Epoch;
    /** The account data */
    data: TData;
    /** Size of the account data */
    space?: bigint;
}
interface ParsedAccountData {
    program: string;
    parsed: unknown;
    space: bigint;
}
interface TransactionStatus {
    slot: Slot;
    confirmations: number | null;
    err: TransactionError | null;
    confirmationStatus?: Commitment;
}
type SignatureStatus = TransactionStatus;
interface SimulatedTransactionResponse {
    err: TransactionError | null;
    logs: string[] | null;
    accounts?: (AccountInfo$2 | null)[] | null;
    unitsConsumed?: bigint;
    returnData?: {
        programId: Address;
        data: [string, 'base64'];
    } | null;
}
interface GetAccountInfoOptions {
    commitment?: Commitment;
    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
    dataSlice?: {
        offset: number;
        length: number;
    };
    minContextSlot?: Slot;
}
interface GetMultipleAccountsOptions {
    commitment?: Commitment;
    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
    dataSlice?: {
        offset: number;
        length: number;
    };
    minContextSlot?: Slot;
}
interface GetProgramAccountsOptions {
    commitment?: Commitment;
    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
    dataSlice?: {
        offset: number;
        length: number;
    };
    minContextSlot?: Slot;
    filters?: ({
        dataSize: bigint;
    } | {
        memcmp: {
            offset: bigint;
            bytes: Base58EncodedBytes;
            encoding: 'base58';
        };
    } | {
        memcmp: {
            offset: bigint;
            bytes: Base64EncodedBytes;
            encoding: 'base64';
        };
    })[];
    withContext?: boolean;
}
interface SendTransactionOptions {
    skipPreflight?: boolean;
    preflightCommitment?: Commitment;
    encoding?: 'base58' | 'base64';
    maxRetries?: number;
    minContextSlot?: Slot;
}

/**
 * API Response Types for GhostSpeak Public API
 *
 * These types match the REST API responses from packages/api
 */
interface ApiGhost {
    address: string;
    owner: string | null;
    status: string;
    firstTxSignature: string;
    firstSeenTimestamp: number;
    discoverySource: string;
    claimedAt: number | null;
    agentId: string;
    name: string;
    description: string;
    metadataUri: string;
    serviceEndpoint: string;
    externalIdentifiers: Array<{
        platform: string;
        externalId: string;
        verified: boolean;
        verifiedAt: number;
    }>;
    ghostScore: number;
    reputationScore: number;
    reputationComponents: Array<{
        source: string;
        score: number;
        weight: number;
        lastUpdated: number;
    }>;
    didAddress: string | null;
    credentials: string[];
    isActive: boolean;
    isVerified: boolean;
    verificationTimestamp: number;
    createdAt: number;
    updatedAt: number;
}
interface ApiGhostScore {
    address: string;
    score: number;
    maxScore: number;
    components: Array<{
        source: string;
        score: number;
        weight: number;
        lastUpdated: number;
    }>;
    lastUpdated: number;
}
interface ApiExternalIdLookup {
    mapping: {
        platform: string;
        externalId: string;
        ghostAddress: string;
        verified: boolean;
        verifiedAt: number | null;
        createdAt: number;
    };
    ghost: ApiGhost | null;
}

/**
 * Calculate visible score based on privacy settings
 *
 * @param score - Actual reputation score
 * @param privacyMode - Privacy mode setting
 * @param hasAccess - Whether viewer has full access
 * @returns Visible score data
 */
declare function calculateVisibleScore(score: number, privacyMode: PrivacyMode, hasAccess: boolean): {
    exactScore?: number;
    tier?: ReputationTier;
    scoreRange?: ScoreRange;
};
/**
 * Get reputation tier from score
 *
 * @param score - Reputation score (0-10000)
 * @returns Reputation tier
 */
declare function getReputationTier(score: number): ReputationTier;
/**
 * Get score range bucket from score
 *
 * @param score - Reputation score (0-10000)
 * @returns Score range bucket
 */
declare function getScoreRange(score: number): ScoreRange;
/**
 * Check if viewer has access to private data
 *
 * @param viewerAddress - Address of the viewer
 * @param settings - Privacy settings
 * @param agentAddress - Agent address (viewer is agent)
 * @returns Whether viewer has access
 */
declare function canViewerAccess(viewerAddress: Address$1, settings: PrivacySettings, agentAddress: Address$1): boolean;
/**
 * Filter reputation metrics by visibility settings
 *
 * @param reputationData - Full reputation data
 * @param metricVisibility - Metric visibility settings
 * @param hasAccess - Whether viewer has full access
 * @returns Filtered visible reputation
 */
declare function filterMetricsByVisibility(reputationData: {
    agent: Address$1;
    overallScore: number;
    totalJobsCompleted: number;
    totalJobsFailed: number;
    avgResponseTime: number;
    disputesAgainst: number;
    disputesResolved: number;
    totalEarnings?: number;
    avgRating?: number;
    badges?: string[];
}, metricVisibility: MetricVisibility, hasAccess: boolean): Partial<VisibleReputation>;
/**
 * Create default metric visibility settings
 *
 * @param mode - Privacy mode
 * @returns Default metric visibility
 */
declare function getDefaultMetricVisibility(mode: PrivacyMode): MetricVisibility;
/**
 * Validate privacy settings
 *
 * @param settings - Privacy settings to validate
 * @returns Validation result with errors if any
 */
declare function validatePrivacySettings(settings: PrivacySettings): {
    valid: boolean;
    errors: string[];
};
/**
 * Get tier display name
 *
 * @param tier - Reputation tier
 * @returns Display name
 */
declare function getTierDisplayName(tier: ReputationTier): string;
/**
 * Get range display string
 *
 * @param range - Score range
 * @returns Display string
 */
declare function getRangeDisplayString(range: ScoreRange): string;

interface RpcClientConfig {
    endpoint: string;
    wsEndpoint?: string;
    commitment?: Commitment;
    maxRetries?: number;
    retryDelay?: number;
    timeout?: number;
}
/**
 * Unified RPC client with all features consolidated from multiple implementations.
 * This is the single source of truth for all RPC operations.
 *
 * Now powered by Gill for simplified client management while maintaining
 * full backward compatibility with the existing API.
 */
declare class RpcClient {
    private client;
    private commitment;
    private endpoint;
    private maxRetries;
    private retryDelay;
    private timeout;
    constructor(config: RpcClientConfig);
    /**
     * Get the underlying RPC client for direct access
     * This provides access to Gill's rpc object for advanced operations
     */
    get rpc(): gill.Rpc<(gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi) | (gill.RequestAirdropApi & gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi)> | gill.RpcDevnet<(gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi) | (gill.RequestAirdropApi & gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi)> | gill.RpcTestnet<(gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi) | (gill.RequestAirdropApi & gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi)> | gill.RpcMainnet<(gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi) | (gill.RequestAirdropApi & gill.GetAccountInfoApi & gill.GetBalanceApi & gill.GetBlockApi & gill.GetBlockCommitmentApi & gill.GetBlockHeightApi & gill.GetBlockProductionApi & gill.GetBlocksApi & gill.GetBlocksWithLimitApi & gill.GetBlockTimeApi & gill.GetClusterNodesApi & gill.GetEpochInfoApi & gill.GetEpochScheduleApi & gill.GetFeeForMessageApi & gill.GetFirstAvailableBlockApi & gill.GetGenesisHashApi & gill.GetHealthApi & gill.GetHighestSnapshotSlotApi & gill.GetIdentityApi & gill.GetInflationGovernorApi & gill.GetInflationRateApi & gill.GetInflationRewardApi & gill.GetLargestAccountsApi & gill.GetLatestBlockhashApi & gill.GetLeaderScheduleApi & gill.GetMaxRetransmitSlotApi & gill.GetMaxShredInsertSlotApi & gill.GetMinimumBalanceForRentExemptionApi & gill.GetMultipleAccountsApi & gill.GetProgramAccountsApi & gill.GetRecentPerformanceSamplesApi & gill.GetRecentPrioritizationFeesApi & gill.GetSignaturesForAddressApi & gill.GetSignatureStatusesApi & gill.GetSlotApi & gill.GetSlotLeaderApi & gill.GetSlotLeadersApi & gill.GetStakeMinimumDelegationApi & gill.GetSupplyApi & gill.GetTokenAccountBalanceApi & gill.GetTokenAccountsByDelegateApi & gill.GetTokenAccountsByOwnerApi & gill.GetTokenLargestAccountsApi & gill.GetTokenSupplyApi & gill.GetTransactionApi & gill.GetTransactionCountApi & gill.GetVersionApi & gill.GetVoteAccountsApi & gill.IsBlockhashValidApi & gill.MinimumLedgerSlotApi & gill.SendTransactionApi & gill.SimulateTransactionApi)>;
    /**
     * Get account information with automatic retries
     */
    getAccountInfo(address: Address$1, options?: GetAccountInfoOptions): Promise<AccountInfo$2 | null>;
    /**
     * Get multiple accounts efficiently
     */
    getMultipleAccounts(addresses: Address$1[], options?: GetMultipleAccountsOptions): Promise<(AccountInfo$2 | null)[]>;
    /**
     * Get program accounts with filters
     */
    getProgramAccounts(programId: Address$1, options?: GetProgramAccountsOptions): Promise<{
        pubkey: Address$1;
        account: AccountInfo$2;
    }[]>;
    /**
     * Get latest blockhash with automatic caching
     */
    private blockhashCache;
    getLatestBlockhash(): Promise<{
        blockhash: string;
        lastValidBlockHeight: bigint;
    }>;
    /**
     * Send transaction with enhanced error handling
     */
    sendTransaction(transaction: Base64EncodedWireTransaction, options?: SendTransactionOptions): Promise<Signature>;
    /**
     * Get signature statuses with batch support
     */
    getSignatureStatuses(signatures: Signature[]): Promise<(SignatureStatus | null)[]>;
    /**
     * Simulate transaction with detailed error info
     */
    simulateTransaction(transaction: Base64EncodedWireTransaction, options?: {
        commitment?: Commitment;
        replaceRecentBlockhash?: boolean;
    }): Promise<SimulatedTransactionResponse>;
    /**
     * Get fee for message
     */
    getFeeForMessage(encodedMessage: TransactionMessageBytesBase64): Promise<bigint | null>;
    /**
     * Health check
     */
    isHealthy(): Promise<boolean>;
    /**
     * Get RPC node version
     */
    getVersion(): Promise<{
        'solana-core': string;
        'feature-set': number;
    }>;
    /**
     * Subscribe to account changes (WebSocket)
     *
     * Note: This is a polling-based implementation for backward compatibility.
     * For production use with real-time subscriptions, access the rpcSubscriptions
     * directly via client.rpcSubscriptions from Gill.
     */
    subscribeToAccount(address: Address$1, callback: (accountInfo: AccountInfo$2 | null) => void): Promise<() => void>;
    /**
     * Get the underlying Gill client for advanced operations
     * This provides direct access to Gill's SolanaClient for features like:
     * - rpcSubscriptions for WebSocket subscriptions
     * - sendAndConfirmTransaction for transaction handling
     */
    getGillClient(): SolanaClient<any>;
    private withRetry;
    private parseAccountInfo;
}

/**
 * Batch Operations - Efficient multi-account fetching
 *
 * Utilities for batching RPC calls to reduce network overhead.
 * Uses Solana's getMultipleAccounts with 100-account limit.
 *
 * @module batch-operations
 */

/**
 * Batch progress callback
 */
type BatchProgressCallback = (completed: number, total: number) => void;
/**
 * Batch fetch configuration
 */
interface BatchFetchConfig {
    /** Progress callback for large batches */
    onProgress?: BatchProgressCallback;
    /** Batch size (default: 100, max: 100) */
    batchSize?: number;
}
/**
 * Batch fetch multiple accounts with automatic chunking
 *
 * Features:
 * - Automatic batching (100 accounts per RPC call)
 * - Parallel batch execution
 * - Progress callback support
 * - Preserves order
 *
 * @param rpc - RPC client
 * @param addresses - Account addresses to fetch
 * @param config - Batch configuration
 * @returns Array of accounts (in same order as input)
 *
 * @example
 * ```typescript
 * const addresses = [...1000 agent addresses...]
 * const accounts = await batchGetAccounts(rpc, addresses, {
 *   onProgress: (completed, total) => {
 *     console.log(`Fetched ${completed}/${total} accounts`)
 *   }
 * })
 * ```
 */
declare function batchGetAccounts<T>(rpc: ExtendedRpcApi, addresses: Address$1[], config?: BatchFetchConfig): Promise<(T | null)[]>;
/**
 * Batch fetch with filtering (only non-null accounts)
 *
 * Useful when you expect some addresses to not exist.
 *
 * @param rpc - RPC client
 * @param addresses - Account addresses to fetch
 * @param config - Batch configuration
 * @returns Array of non-null accounts with their addresses
 *
 * @example
 * ```typescript
 * const addresses = [...agent addresses...]
 * const existing = await batchGetExistingAccounts(rpc, addresses)
 * // Returns only accounts that exist: [{ address, account }, ...]
 * ```
 */
declare function batchGetExistingAccounts<T>(rpc: ExtendedRpcApi, addresses: Address$1[], config?: BatchFetchConfig): Promise<Array<{
    address: Address$1;
    account: T;
}>>;
/**
 * Batch fetch with mapping
 *
 * Fetches accounts and immediately maps them to a transformed type.
 *
 * @param rpc - RPC client
 * @param addresses - Account addresses to fetch
 * @param mapper - Transform function (account, address, index) => result
 * @param config - Batch configuration
 * @returns Array of mapped results
 *
 * @example
 * ```typescript
 * const agentSummaries = await batchGetAndMap(
 *   rpc,
 *   agentAddresses,
 *   (account, address) => ({
 *     address,
 *     name: account.data.name,
 *     reputation: account.data.totalScore
 *   })
 * )
 * ```
 */
declare function batchGetAndMap<T, R>(rpc: ExtendedRpcApi, addresses: Address$1[], mapper: (account: T | null, address: Address$1, index: number) => R, config?: BatchFetchConfig): Promise<R[]>;
/**
 * Batch fetch with retry logic
 *
 * Retries failed batches with exponential backoff.
 *
 * @param rpc - RPC client
 * @param addresses - Account addresses to fetch
 * @param config - Batch configuration
 * @param maxRetries - Maximum retry attempts (default: 3)
 * @returns Array of accounts
 */
declare function batchGetAccountsWithRetry<T>(rpc: ExtendedRpcApi, addresses: Address$1[], config?: BatchFetchConfig, maxRetries?: number): Promise<(T | null)[]>;
/**
 * Create a batch fetcher with reusable configuration
 *
 * Factory pattern for creating pre-configured batch fetchers.
 *
 * @param rpc - RPC client
 * @param defaultConfig - Default batch configuration
 * @returns Batch fetcher functions
 *
 * @example
 * ```typescript
 * const fetcher = createBatchFetcher(rpc, {
 *   batchSize: 50,
 *   onProgress: (c, t) => console.log(`${c}/${t}`)
 * })
 *
 * const accounts = await fetcher.getAccounts(addresses)
 * const existing = await fetcher.getExisting(addresses)
 * ```
 */
declare function createBatchFetcher(rpc: ExtendedRpcApi, defaultConfig?: BatchFetchConfig): {
    /**
     * Fetch multiple accounts
     */
    getAccounts: <T>(addresses: Address$1[], config?: BatchFetchConfig) => Promise<(T | null)[]>;
    /**
     * Fetch only existing accounts
     */
    getExisting: <T>(addresses: Address$1[], config?: BatchFetchConfig) => Promise<{
        address: Address$1;
        account: T;
    }[]>;
    /**
     * Fetch and map accounts
     */
    getAndMap: <T, R>(addresses: Address$1[], mapper: (account: T | null, address: Address$1, index: number) => R, config?: BatchFetchConfig) => Promise<R[]>;
    /**
     * Fetch with retry logic
     */
    getWithRetry: <T>(addresses: Address$1[], config?: BatchFetchConfig, maxRetries?: number) => Promise<(T | null)[]>;
};

/**
 * ExternalIdResolver - Cross-Platform Identity Lookup
 *
 * Resolves platform-specific IDs (PayAI, ElizaOS, etc.) to Ghost addresses
 * Uses GhostSpeak Public API for fast lookups
 */

interface ApiResolverConfig {
    apiUrl?: string;
    cluster?: 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
}
declare class ExternalIdResolver {
    private apiUrl;
    constructor(config?: ApiResolverConfig);
    /**
     * Resolve external ID to Ghost address
     *
     * @example
     * const address = await resolver.resolve('payai', 'agent-123');
     */
    resolve(platform: string, externalId: string): Promise<Address$1>;
    /**
     * Lookup external ID with full Ghost data
     *
     * @example
     * const { mapping, ghost } = await resolver.lookup('payai', 'agent-123');
     */
    lookup(platform: string, externalId: string): Promise<ApiExternalIdLookup>;
    /**
     * Get Ghost by Solana address via API
     *
     * Faster than on-chain lookup for read operations
     */
    getGhost(ghostAddress: Address$1 | string): Promise<ApiGhost>;
    /**
     * Get Ghost Score via API
     */
    getGhostScore(ghostAddress: Address$1 | string): Promise<ApiGhostScore>;
    /**
     * Get detailed reputation breakdown via API
     */
    getGhostReputation(ghostAddress: Address$1 | string): Promise<any>;
    /**
     * Batch resolve multiple external IDs
     */
    resolveBatch(identifiers: Array<{
        platform: string;
        externalId: string;
    }>): Promise<Array<Address$1 | null>>;
    /**
     * Check if external ID exists
     */
    exists(platform: string, externalId: string): Promise<boolean>;
    /**
     * Get all external IDs for a Ghost
     *
     * Fetches Ghost data and returns external identifiers
     */
    getExternalIds(ghostAddress: Address$1 | string): Promise<Array<{
        platform: string;
        externalId: string;
        verified: boolean;
        verifiedAt: number;
    }>>;
    /**
     * Search for Ghost by partial platform ID
     *
     * Note: This is a client-side filter, not server-side search
     * For production, implement server-side search endpoint
     */
    searchByExternalId(platform: string, partialId: string): Promise<ApiExternalIdLookup[]>;
    /**
     * Set custom API URL
     */
    setApiUrl(apiUrl: string): void;
    /**
     * Get current API URL
     */
    getApiUrl(): string;
    /**
     * Check API health
     */
    checkHealth(): Promise<{
        status: string;
        network: string;
        rpc: {
            connected: boolean;
            latency: number;
        };
    }>;
}

interface CreateEscrowParams {
    /** Agent providing the service */
    agent: Address$1;
    /** Client's token account for payment */
    clientTokenAccount: Address$1;
    /** Vault to hold escrowed funds */
    escrowVault: Address$1;
    /** Token mint (e.g., USDC, GHOST) */
    tokenMint: Address$1;
    /** Client who is paying */
    client: TransactionSigner;
    /** Unique escrow identifier */
    escrowId: bigint;
    /** Amount to escrow */
    amount: bigint;
    /** Description of the job/service */
    jobDescription: string;
    /** Deadline timestamp (unix seconds) */
    deadline: bigint;
}
interface SubmitDeliveryParams {
    /** Escrow account */
    escrow: Address$1;
    /** Agent account address */
    agent: Address$1;
    /** Agent owner signer */
    agentOwner: TransactionSigner;
    /** Proof of work (IPFS hash, URL, etc.) */
    deliveryProof: string;
}
interface ApproveDeliveryParams {
    /** Escrow account */
    escrow: Address$1;
    /** Vault holding escrowed funds */
    escrowVault: Address$1;
    /** Agent's token account to receive payment */
    agentTokenAccount: Address$1;
    /** Client approving the delivery */
    client: TransactionSigner;
}
interface FileDisputeParams {
    /** Escrow account */
    escrow: Address$1;
    /** Client filing the dispute */
    client: TransactionSigner;
    /** Reason for dispute */
    reason: string;
}
interface ArbitrateDisputeParams {
    /** Escrow account */
    escrow: Address$1;
    /** Vault holding escrowed funds */
    escrowVault: Address$1;
    /** Client's token account (for refund) */
    clientTokenAccount: Address$1;
    /** Agent's token account (for payment) */
    agentTokenAccount: Address$1;
    /** Agent's staking account (for potential slashing) */
    agentStaking: Address$1;
    /** Arbitrator making the decision */
    arbitrator: TransactionSigner;
    /** Decision: FavorClient, FavorAgent, Split, or Invalid */
    decision: ArbitratorDecision;
}
declare class EscrowModule extends BaseModule {
    /**
     * Create a new escrow for a service agreement
     *
     * @param params - Escrow creation parameters
     * @returns Transaction signature
     */
    createEscrow(params: CreateEscrowParams): Promise<string>;
    /**
     * Submit proof of delivery for an escrow
     *
     * @param params - Delivery submission parameters
     * @returns Transaction signature
     */
    submitDelivery(params: SubmitDeliveryParams): Promise<string>;
    /**
     * Approve delivery and release funds to agent
     *
     * @param params - Approval parameters
     * @returns Transaction signature
     */
    approveDelivery(params: ApproveDeliveryParams): Promise<string>;
    /**
     * File a dispute for an escrow
     *
     * @param params - Dispute filing parameters
     * @returns Transaction signature
     */
    fileDispute(params: FileDisputeParams): Promise<string>;
    /**
     * Arbitrate a disputed escrow
     *
     * @param params - Arbitration parameters
     * @returns Transaction signature
     */
    arbitrateDispute(params: ArbitrateDisputeParams): Promise<string>;
    /**
     * Get escrow account data
     *
     * @param escrowAddress - The escrow account address
     * @returns Escrow data or null if not found
     */
    getEscrow(escrowAddress: Address$1): Promise<GhostProtectEscrow | null>;
}

/**
 * X402 Transaction Indexer
 *
 * Polls Solana blockchain for x402 payment transactions to eliminate
 * webhook dependency and enable historical reputation backfilling.
 *
 * x402 payments are SPL token transfers (USDC) to PayAI facilitator addresses.
 * This indexer discovers these transfers and extracts payment metadata.
 *
 * @module modules/indexer
 */

/**
 * Parsed x402 payment data from on-chain transaction
 */
interface X402PaymentData {
    /** Transaction signature (on-chain proof) */
    signature: string;
    /** Merchant (agent) receiving payment */
    merchant: Address;
    /** Payer sending payment */
    payer: Address;
    /** Payment amount in token base units (e.g., micro-USDC) */
    amount: string;
    /** Payment success status */
    success: boolean;
    /** Block timestamp */
    timestamp: Date;
    /** Solana network */
    network: 'solana' | 'solana-devnet';
    /** Response time in milliseconds (if available from memo) */
    responseTimeMs?: number;
    /** Additional metadata from transaction memo */
    metadata?: Record<string, unknown>;
}
/**
 * Transaction signature with metadata
 */
interface SignatureInfo {
    signature: Signature;
    slot: bigint;
    blockTime: bigint | null;
    err: unknown | null;
}
/**
 * Indexer configuration
 */
interface X402IndexerConfig {
    /** Solana RPC client */
    rpc: Rpc<GetSignaturesForAddressApi & GetTransactionApi>;
    /** PayAI facilitator address to monitor */
    facilitatorAddress: Address;
    /** Network identifier */
    network?: 'solana' | 'solana-devnet';
    /** Maximum transactions per poll */
    batchSize?: number;
}
/**
 * X402 Transaction Indexer
 *
 * Discovers x402 payments by monitoring SPL token transfers
 * to PayAI facilitator addresses on Solana.
 *
 * @example
 * ```typescript
 * const indexer = new X402TransactionIndexer({
 *   rpc: createSolanaRpc('https://api.devnet.solana.com'),
 *   facilitatorAddress: address('PayAI...'),
 *   network: 'solana-devnet',
 * })
 *
 * // Poll for new transactions
 * const payments = await indexer.pollTransactions()
 * ```
 */
declare class X402TransactionIndexer {
    private readonly rpc;
    private readonly facilitatorAddress;
    private readonly network;
    private readonly batchSize;
    constructor(config: X402IndexerConfig);
    /**
     * Poll for new x402 transactions since last sync
     *
     * @param lastSignature - Last processed signature (for pagination)
     * @param limit - Maximum transactions to fetch
     * @returns Array of parsed x402 payment data
     */
    pollTransactions(lastSignature?: Signature, limit?: number): Promise<X402PaymentData[]>;
    /**
     * Parse a specific transaction signature
     *
     * @param signature - Transaction signature to parse
     * @returns Parsed x402 payment data or null if not an x402 payment
     */
    parseTransaction(sig: Signature | string): Promise<X402PaymentData | null>;
    /**
     * Fetch transaction signatures for the facilitator address
     */
    private getSignatures;
    /**
     * Check if transaction is an x402 payment
     *
     * x402 payments are characterized by:
     * - SPL token transfer (TokenProgram or Token2022Program) for USDC
     * - Native SOL transfer (System Program)
     * - Transfer TO the facilitator address
     * - Optional memo instruction with payment metadata
     *
     * Supports both devnet and mainnet for all payment types
     */
    private isX402Payment;
    /**
     * Extract payment data from transaction
     */
    private extractPaymentData;
}

/**
 * Reputation Source Adapter Interface
 *
 * Base interface for all reputation data sources (PayAI, GitHub, custom webhooks, etc.)
 * Each adapter normalizes external data to a standard format for aggregation.
 */
/**
 * Supported reputation sources
 */
declare enum ReputationSource {
    PayAI = "payai",
    DirectSolana = "direct-solana",
    GitHub = "github",
    Twitter = "twitter",
    CustomWebhook = "custom-webhook",
    OnChainHistory = "onchain-history"
}
/**
 * Configuration for a reputation source
 */
interface ReputationSourceConfig {
    /** Source identifier */
    source: ReputationSource;
    /** Weight in basis points (0-10000) */
    weight: number;
    /** Reliability score in basis points (0-10000) */
    reliability: number;
    /** Source-specific configuration (API keys, URLs, etc.) */
    config: Record<string, any>;
    /** Whether this source is enabled */
    enabled: boolean;
}
/**
 * Normalized reputation data from a source
 */
interface SourceReputationData {
    /** Source identifier */
    source: ReputationSource;
    /** Reputation score (0-1000) */
    score: number;
    /** Number of data points contributing to score */
    dataPoints: number;
    /** Reliability of this data (0-1) */
    reliability: number;
    /** Raw data from source (for debugging/audit) */
    rawData: any;
    /** Timestamp when data was fetched */
    timestamp: Date;
}
/**
 * Base interface for reputation source adapters
 */
interface ReputationSourceAdapter {
    /** Source identifier */
    readonly source: ReputationSource;
    /**
     * Fetch reputation data for an agent
     *
     * @param agentId - Agent identifier (public key or external ID)
     * @returns Normalized reputation data
     */
    fetchReputationData(agentId: string): Promise<SourceReputationData>;
    /**
     * Validate raw data from source
     *
     * @param data - Raw data to validate
     * @returns True if data is valid
     */
    validateData(data: any): boolean;
    /**
     * Normalize raw score to 0-1000 scale
     *
     * @param rawScore - Raw score from source
     * @returns Normalized score (0-1000)
     */
    normalizeScore(rawScore: any): number;
    /**
     * Calculate reliability score for this data point
     *
     * @param data - Source data
     * @returns Reliability (0-1)
     */
    calculateReliability(data: any): number;
}
/**
 * Abstract base class for reputation adapters
 */
declare abstract class BaseReputationAdapter implements ReputationSourceAdapter {
    protected config: ReputationSourceConfig;
    constructor(config: ReputationSourceConfig);
    abstract get source(): ReputationSource;
    abstract fetchReputationData(agentId: string): Promise<SourceReputationData>;
    abstract validateData(data: any): boolean;
    abstract normalizeScore(rawScore: any): number;
    /**
     * Default reliability calculation uses configured reliability
     */
    calculateReliability(_data: any): number;
    /**
     * Check if adapter is enabled
     */
    isEnabled(): boolean;
    /**
     * Get adapter weight in basis points
     */
    getWeight(): number;
    /**
     * Validate score is in valid range (0-1000)
     */
    protected validateScoreRange(score: number): boolean;
    /**
     * Clamp score to valid range
     */
    protected clampScore(score: number): number;
}

/**
 * Multi-Source Reputation Aggregator
 *
 * Aggregates reputation data from multiple sources (PayAI, GitHub, custom webhooks)
 * with weighted scoring, conflict detection, and reliability-based adjustments.
 *
 * Based on MUSCLE multi-source oracle pattern with reputation-based source selection.
 */

/**
 * Aggregated reputation result
 */
interface AggregatedReputation {
    /** Agent address */
    agentId: Address$1 | string;
    /** Weighted aggregate score (0-1000) */
    aggregateScore: number;
    /** Individual source scores */
    sourceScores: SourceScoreBreakdown[];
    /** Whether conflicts were detected */
    hasConflicts: boolean;
    /** Conflict descriptions */
    conflicts: string[];
    /** Total number of data points across all sources */
    totalDataPoints: number;
    /** Timestamp of aggregation */
    timestamp: Date;
}
/**
 * Individual source score breakdown
 */
interface SourceScoreBreakdown {
    /** Source identifier */
    source: ReputationSource;
    /** Raw score from source (0-1000) */
    score: number;
    /** Source weight (0-10000 basis points) */
    weight: number;
    /** Source reliability (0-10000 basis points) */
    reliability: number;
    /** Number of data points */
    dataPoints: number;
    /** Weighted contribution to final score */
    contribution: number;
    /** Last updated timestamp */
    lastUpdated: Date;
}
/**
 * Multi-source reputation aggregator
 */
declare class MultiSourceAggregator {
    private adapters;
    private configs;
    /** Conflict threshold (30% variance) */
    private readonly CONFLICT_THRESHOLD;
    /**
     * Create a new multi-source aggregator
     */
    constructor();
    /**
     * Add a reputation source
     *
     * @param adapter - Reputation source adapter
     * @param config - Source configuration
     */
    addSource(adapter: ReputationSourceAdapter, config: ReputationSourceConfig): void;
    /**
     * Remove a reputation source
     *
     * @param source - Source to remove
     */
    removeSource(source: ReputationSource): void;
    /**
     * Update source weight
     *
     * @param source - Source to update
     * @param weight - New weight in basis points (0-10000)
     */
    updateSourceWeight(source: ReputationSource, weight: number): void;
    /**
     * Update source reliability
     *
     * @param source - Source to update
     * @param reliability - New reliability in basis points (0-10000)
     */
    updateSourceReliability(source: ReputationSource, reliability: number): void;
    /**
     * Aggregate reputation from all sources
     *
     * @param agentId - Agent identifier
     * @returns Aggregated reputation data
     */
    aggregateReputation(agentId: Address$1 | string): Promise<AggregatedReputation>;
    /**
     * Calculate weighted aggregate score
     *
     * Formula: Σ(score × weight × reliability) / Σ(weight × reliability)
     *
     * @param sourceDataList - Data from all sources
     * @returns Weighted aggregate score (0-1000)
     */
    calculateWeightedScore(sourceDataList: SourceReputationData[]): number;
    /**
     * Detect conflicts between sources
     *
     * Flags conflicts if max_score - min_score > 30%
     *
     * @param sourceDataList - Data from all sources
     * @returns Conflict detection result
     */
    detectConflicts(sourceDataList: SourceReputationData[]): {
        hasConflicts: boolean;
        conflicts: string[];
    };
    /**
     * Build source score breakdowns
     *
     * @param sourceDataList - Data from all sources
     * @returns Source score breakdowns
     */
    private buildSourceBreakdowns;
    /**
     * Calculate normalization factor for weighted scoring
     */
    private calculateNormalizationFactor;
    /**
     * Get detailed source breakdown for an agent
     *
     * @param agentId - Agent identifier
     * @returns Source breakdowns with full details
     */
    getSourceBreakdown(agentId: Address$1 | string): Promise<SourceScoreBreakdown[]>;
    /**
     * Get list of registered sources
     */
    getRegisteredSources(): ReputationSource[];
    /**
     * Get source configuration
     *
     * @param source - Source identifier
     * @returns Source configuration or undefined
     */
    getSourceConfig(source: ReputationSource): ReputationSourceConfig | undefined;
    /**
     * Enable a source
     *
     * @param source - Source to enable
     */
    enableSource(source: ReputationSource): void;
    /**
     * Disable a source
     *
     * @param source - Source to disable
     */
    disableSource(source: ReputationSource): void;
    /**
     * Check if source is enabled
     *
     * @param source - Source to check
     * @returns True if enabled
     */
    isSourceEnabled(source: ReputationSource): boolean;
}

/**
 * This file is auto-generated by scripts/generate-mappings.ts
 * Do not edit this file manually.
 */
interface AccountInfo$1 {
    name: string;
    writable: boolean;
    signer: boolean;
    optional: boolean;
    docs: string[];
    address?: string;
    pda?: {
        seeds: unknown[];
    };
}
interface ExpectedAccount {
    name: string;
    pda: boolean;
}
interface InstructionMapping {
    name: string;
    expectedAccounts: ExpectedAccount[];
    accounts: AccountInfo$1[];
    docs?: string;
    discriminator: number[];
    args: unknown[];
}

/**
 * Instruction Error Handler
 *
 * Provides detailed error messages for instruction account validation
 * using the generated instruction mappings from the IDL.
 */

interface AccountInfo {
    name: string;
    pda: boolean;
}
/**
 * Enhanced error class for instruction validation errors
 */
declare class InstructionValidationError extends Error {
    readonly instruction: string;
    readonly expectedAccounts: number;
    readonly providedAccounts: number;
    readonly accountDetails?: AccountInfo[];
    constructor(instruction: string, expectedAccounts: number, providedAccounts: number, message: string, accountDetails?: AccountInfo[]);
}
/**
 * Check if an instruction exists in our mappings
 */
declare function isKnownInstruction(instructionName: string): boolean;
/**
 * Validate instruction accounts and throw detailed error if invalid
 */
declare function validateInstructionAccounts(instructionName: string, providedAccounts: unknown[], accountNames?: string[]): void;
/**
 * Create a helpful error message for account mismatch
 */
declare function createAccountMismatchError(instructionName: string, providedCount: number, providedAccountNames?: string[]): string;
/**
 * Get human-readable account requirements for an instruction
 */
declare function getAccountRequirements(instructionName: string): string;
/**
 * Get instruction mapping (exported for external use)
 */
declare function getInstructionMapping(instructionName: string): InstructionMapping | null;
/**
 * Generate account validation error message (exported for external use)
 */
declare function generateAccountValidationError(instructionName: string, providedCount: number, accountNames?: string[]): string;
/**
 * Enhanced error message helper
 */
declare function enhanceErrorMessage(error: Error, context: string): string;
/**
 * Debug instruction call helper
 */
declare function debugInstructionCall(instructionName: string, accounts: unknown[]): string;
/**
 * Get required signers for an instruction
 */
declare function getRequiredSigners(instructionName: string): string[];
/**
 * Get writable accounts for an instruction
 */
declare function getWritableAccounts(instructionName: string): string[];
/**
 * Get PDA accounts for an instruction
 */
declare function getPDAAccounts(instructionName: string): string[];
/**
 * Instruction mappings constant for external access
 */
declare const INSTRUCTION_MAPPINGS: Record<string, InstructionMapping>;

/**
 * Utility functions for IPFS operations in GhostSpeak
 */

/**
 * Default IPFS configuration for GhostSpeak
 */
declare const DEFAULT_IPFS_CONFIG: IPFSConfig;
/**
 * IPFS utility class with convenience methods
 */
declare class IPFSUtils {
    client: IPFSClient;
    constructor(config: IPFSConfig);
    /**
     * Store agent metadata with automatic IPFS/inline decision
     */
    storeAgentMetadata(metadata: {
        name: string;
        description: string;
        capabilities: string[];
        serviceEndpoint: string;
        agentId?: string;
        [key: string]: unknown;
    }, options?: IPFSUploadOptions): Promise<ContentStorageResult>;
    /**
     * Store channel message content with automatic IPFS/inline decision
     */
    storeChannelMessage(message: {
        content: string;
        messageType?: number;
        attachments?: string[];
        channelId?: string;
        sender?: string;
        [key: string]: unknown;
    }, options?: IPFSUploadOptions): Promise<ContentStorageResult>;
    /**
     * Store file attachments on IPFS
     */
    storeFileAttachment(fileContent: Uint8Array | string, filename: string, contentType: string, options?: IPFSUploadOptions): Promise<ContentStorageResult>;
    /**
     * Retrieve and parse agent metadata
     */
    retrieveAgentMetadata(uri: string): Promise<{
        name: string;
        description: string;
        capabilities: string[];
        serviceEndpoint: string;
        agentId?: string;
        createdAt?: string;
        [key: string]: unknown;
    }>;
    /**
     * Retrieve and parse channel message content
     */
    retrieveChannelMessage(uri: string): Promise<{
        content: string;
        messageType?: number;
        attachments?: string[];
        timestamp?: string;
        [key: string]: unknown;
    }>;
    /**
     * Batch upload multiple content items
     */
    batchUpload(items: {
        content: string;
        type: IPFSContentMetadata['type'];
        filename?: string;
        options?: IPFSUploadOptions;
    }[]): Promise<IPFSOperationResult<ContentStorageResult>[]>;
    /**
     * Pin existing content by hash
     */
    pinContent(hash: string): Promise<IPFSOperationResult<boolean>>;
    /**
     * Check if a URI uses IPFS storage
     */
    isIPFSUri(uri: string): boolean;
    /**
     * Extract IPFS hash from URI
     */
    extractIPFSHash(uri: string): string | null;
    /**
     * Convert IPFS hash to gateway URLs
     */
    getGatewayUrls(hash: string, gateways?: string[]): string[];
    /**
     * Validate IPFS hash format
     */
    isValidIPFSHash(hash: string): boolean;
    /**
     * Calculate content size to determine if IPFS should be used
     */
    shouldUseIPFS(content: string, threshold?: number): boolean;
    /**
     * Compress content before IPFS upload using modern compression APIs
     */
    compressContent(content: string): Promise<{
        compressed: string;
        algorithm: string;
    }>;
    /**
     * Decompress content after IPFS retrieval using modern decompression APIs
     */
    decompressContent(compressed: string, algorithm: string): Promise<string>;
    /**
     * Get client stats
     */
    getStats(): {
        cacheStats: {
            size: number;
            keys: string[];
        };
        config: IPFSConfig;
    };
    /**
     * Clear client cache
     */
    clearCache(): void;
}
/**
 * Create an IPFS utility instance with configuration
 */
declare function createIPFSUtils(config?: Partial<IPFSConfig>): IPFSUtils;
/**
 * Helper function to determine optimal storage method
 */
declare function determineStorageMethod(content: string, options?: {
    sizeThreshold?: number;
    forceIPFS?: boolean;
    forceInline?: boolean;
}): 'inline' | 'ipfs';
/**
 * Create metadata URI with automatic storage decision
 */
declare function createMetadataUri(metadata: Record<string, unknown>, ipfsUtils?: IPFSUtils, options?: {
    type?: IPFSContentMetadata['type'];
    filename?: string;
    forceIPFS?: boolean;
}): Promise<string>;

/**
 * Test IPFS configuration for beta testing and development
 */

/**
 * Test IPFS configuration that uses the in-memory test provider
 * This configuration does not require any external services
 */
declare const TEST_IPFS_CONFIG: IPFSConfig;
/**
 * Create a test IPFS configuration with custom options
 */
declare function createTestIPFSConfig(options?: Partial<IPFSConfig>): IPFSConfig;

/**
 * Enhanced error handling and retry logic for IPFS operations in GhostSpeak
 */

/**
 * IPFS-specific error class with enhanced context
 */
declare class IPFSOperationError extends Error {
    readonly type: IPFSError;
    readonly provider?: string | undefined;
    readonly retryCount?: number | undefined;
    readonly originalError?: Error | undefined;
    constructor(type: IPFSError, message: string, provider?: string | undefined, retryCount?: number | undefined, originalError?: Error | undefined);
}
/**
 * Configuration for retry logic
 */
interface RetryConfig {
    maxRetries: number;
    baseDelay: number;
    maxDelay: number;
    backoffFactor: number;
    retryableErrors: IPFSError[];
}
/**
 * Default retry configuration
 */
declare const DEFAULT_RETRY_CONFIG: RetryConfig;
/**
 * Circuit breaker for preventing cascading failures
 */
declare class CircuitBreaker {
    private readonly failureThreshold;
    private readonly recoveryTime;
    private failures;
    private lastFailureTime;
    private state;
    constructor(failureThreshold?: number, recoveryTime?: number);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): {
        state: string;
        failures: number;
        lastFailureTime: number;
    };
    reset(): void;
}
/**
 * Enhanced retry utility with exponential backoff
 */
declare class RetryHandler {
    private readonly config;
    private circuitBreaker;
    constructor(config?: RetryConfig);
    execute<T>(operation: () => Promise<T>, context?: string): Promise<T>;
    private shouldRetry;
    private calculateDelay;
    private categorizeError;
    getStats(): {
        circuitBreakerState: ReturnType<CircuitBreaker['getState']>;
        config: RetryConfig;
    };
    reset(): void;
}
/**
 * Fallback handler for graceful degradation
 */
declare class FallbackHandler {
    private fallbackStrategies;
    constructor();
    private setupDefaultFallbacks;
    handleError<T>(error: IPFSOperationError, fallbackValue?: T): Promise<T>;
    registerFallback<T>(errorType: IPFSError, strategy: (error: IPFSOperationError) => Promise<T>): void;
}
/**
 * Comprehensive error handler that combines retry logic with fallback strategies
 */
declare class IPFSErrorHandler {
    private retryHandler;
    private fallbackHandler;
    constructor(retryConfig?: Partial<RetryConfig>);
    executeWithErrorHandling<T>(operation: () => Promise<IPFSOperationResult<T>>, context?: string, fallbackValue?: T): Promise<IPFSOperationResult<T>>;
    /**
     * Register a custom fallback strategy
     */
    registerFallback<T>(errorType: IPFSError, strategy: (error: IPFSOperationError) => Promise<T>): void;
    /**
     * Get error handler statistics
     */
    getStats(): {
        retryStats: ReturnType<RetryHandler['getStats']>;
        registeredFallbacks: IPFSError[];
    };
    /**
     * Reset all error handling state
     */
    reset(): void;
}
/**
 * Utility function to create a configured error handler
 */
declare function createIPFSErrorHandler(config?: {
    retryConfig?: Partial<RetryConfig>;
    customFallbacks?: {
        errorType: IPFSError;
        strategy: (error: IPFSOperationError) => Promise<unknown>;
    }[];
}): IPFSErrorHandler;
/**
 * Type guard to check if an error is an IPFS error
 */
declare function isIPFSError(error: unknown): error is IPFSOperationError;
/**
 * Helper function to wrap any IPFS operation with error handling
 */
declare function withIPFSErrorHandling<T>(operation: () => Promise<T>, context?: string, errorHandler?: IPFSErrorHandler): Promise<IPFSOperationResult<T>>;

/**
 * Wallet Funding Utilities
 *
 * Provides robust wallet funding strategies that don't depend solely on unreliable devnet airdrops.
 * Supports multiple funding strategies with automatic fallback mechanisms.
 */

/**
 * Funding strategy options
 */
interface FundingStrategyOptions {
    /** Target amount in lamports */
    amount: bigint;
    /** Minimum amount required (if less, will try to top up) */
    minAmount?: bigint;
    /** Maximum retries for airdrop */
    maxRetries?: number;
    /** Delay between retries in ms */
    retryDelay?: number;
    /** Use treasury wallet if available */
    useTreasury?: boolean;
    /** Treasury wallet path or signer */
    treasuryWallet?: string | KeyPairSigner;
    /** Additional funded wallets to try */
    fundedWallets?: (string | KeyPairSigner)[];
    /** Log funding attempts */
    verbose?: boolean;
}
/**
 * Funding result
 */
interface FundingResult {
    /** Whether funding was successful */
    success: boolean;
    /** Final balance after funding */
    balance: bigint;
    /** Funding method used */
    method: 'airdrop' | 'treasury' | 'funded-wallet' | 'existing';
    /** Number of attempts made */
    attempts: number;
    /** Error if funding failed */
    error?: string;
    /** Transaction signature if transfer was made */
    signature?: string;
}
/**
 * Wallet funding utility with multiple strategies
 */
declare class WalletFundingService {
    private rpc;
    private commitment;
    private isDevnetUrl;
    constructor(rpcUrl: string, commitment?: Commitment$1);
    /**
     * Fund a wallet using multiple strategies
     */
    fundWallet(targetWallet: Address, options: FundingStrategyOptions): Promise<FundingResult>;
    /**
     * Try to fund using devnet airdrop with retries
     */
    private tryAirdrop;
    /**
     * Try to fund from treasury wallet
     */
    private tryTreasuryFunding;
    /**
     * Try to fund from another funded wallet
     */
    private tryFundedWalletTransfer;
    /**
     * Transfer SOL from one wallet to another
     */
    private transferSol;
    /**
     * Load wallet from path or return existing signer
     */
    private loadWallet;
    /**
     * Load wallet from base58 private key
     */
    static loadWalletFromBase58(base58PrivateKey: string): Promise<KeyPairSigner>;
    /**
     * Get wallet balance
     */
    getBalance(wallet: Address): Promise<bigint>;
    /**
     * Check if connected to devnet
     */
    private isDevnet;
    /**
     * Format lamports as SOL
     */
    private formatSol;
    /**
     * Create and fund multiple test wallets
     */
    createAndFundTestWallets(count: number, amountPerWallet: bigint, options: Omit<FundingStrategyOptions, 'amount'>): Promise<KeyPairSigner[]>;
    /**
     * Ensure minimum balance for a wallet
     */
    ensureMinimumBalance(wallet: Address, minBalance: bigint, options?: Partial<FundingStrategyOptions>): Promise<FundingResult>;
}
/**
 * Default funding service instance for devnet
 */
declare const defaultFundingService: WalletFundingService;
/**
 * Quick helper to fund a wallet with default settings
 */
declare function fundWallet(wallet: Address, amountInSol: number, options?: Partial<FundingStrategyOptions>): Promise<FundingResult>;
/**
 * Quick helper to ensure minimum balance
 */
declare function ensureMinimumBalance(wallet: Address, minBalanceInSol: number, options?: Partial<FundingStrategyOptions>): Promise<FundingResult>;

/**
 * Private Metadata Storage
 *
 * Handles off-chain storage of encrypted data with on-chain references.
 * Supports IPFS and other storage backends for private data while
 * maintaining on-chain integrity verification.
 */

interface StorageProvider {
    store(data: Uint8Array): Promise<string>;
    retrieve(hash: string): Promise<Uint8Array>;
    delete(hash: string): Promise<boolean>;
}
interface StoredPrivateData {
    /** On-chain reference hash */
    onChainHash: Uint8Array;
    /** Storage provider identifier */
    storageProvider: 'ipfs' | 'arweave' | 'custom';
    /** Storage location (IPFS hash, Arweave ID, etc) */
    storageLocation: string;
    /** Encryption metadata */
    encryptionMetadata: {
        version: number;
        publicKey: Uint8Array;
        timestamp: number;
    };
    /** Size of stored data */
    size: number;
    /** Content type hint */
    contentType?: string;
}
interface PrivateDataReference {
    /** Account storing the reference */
    account: Address;
    /** Storage details */
    storage: StoredPrivateData;
    /** Access control */
    accessControl: {
        owner: Address;
        allowedReaders: Address[];
        expiresAt?: number;
    };
}
/**
 * Real IPFS storage provider using kubo-rpc-client (2025)
 * Connects to actual IPFS nodes for production use
 *
 * SECURITY NOTICE (Kluster MCP):
 * - All data stored is encrypted client-side before IPFS upload
 * - Use private IPFS networks for sensitive production data
 * - Implement proper key management and rotation policies
 * - Monitor for unauthorized access patterns
 */
declare class IPFSProvider implements StorageProvider {
    private client;
    private readonly isPrivateNetwork;
    constructor(options?: {
        ipfsNodeUrl?: string;
        headers?: Record<string, string>;
        usePrivateNetwork?: boolean;
    });
    store(data: Uint8Array): Promise<string>;
    /**
     * Basic heuristic to detect potentially unencrypted data
     * This is not foolproof but can catch obvious cases
     */
    private isDataUnencrypted;
    retrieve(hash: string): Promise<Uint8Array>;
    delete(hash: string): Promise<boolean>;
}
/**
 * Local storage provider (for development)
 */
declare class LocalStorageProvider implements StorageProvider {
    private prefix;
    store(data: Uint8Array): Promise<string>;
    retrieve(hash: string): Promise<Uint8Array>;
    delete(hash: string): Promise<boolean>;
}
declare class PrivateMetadataStorage {
    private encryptionService;
    private storageProvider;
    private featureFlags;
    constructor(storageProvider?: StorageProvider, encryptionService?: ClientEncryptionService);
    /**
     * Store private data off-chain with on-chain reference
     */
    storePrivateData(data: Record<string, unknown>, publicMetadata: Record<string, unknown>, recipientPubkey: Uint8Array): Promise<StoredPrivateData>;
    /**
     * Retrieve private data from off-chain storage
     */
    retrievePrivateData(reference: StoredPrivateData, secretKey: Uint8Array): Promise<{
        privateData: Record<string, unknown>;
        publicData: Record<string, unknown>;
    }>;
    /**
     * Create a verifiable link between on-chain and off-chain data
     */
    createVerifiableLink(onChainData: Record<string, unknown>, offChainReference: StoredPrivateData): Uint8Array;
    /**
     * Batch store multiple private data items
     */
    batchStore(items: {
        data: Record<string, unknown>;
        publicMetadata: Record<string, unknown>;
        recipientPubkey: Uint8Array;
    }[]): Promise<StoredPrivateData[]>;
    private serializePrivateMetadata;
    private deserializePrivateMetadata;
    private createOnChainHash;
    private decryptPrivateData;
}
/**
 * Query builder for private data
 */
declare class PrivateDataQuery {
    private conditions;
    where(field: string, operator: 'eq' | 'gt' | 'lt' | 'contains', value: unknown): this;
    whereEncrypted(field: string, commitment: Uint8Array): this;
    /**
     * Execute query against encrypted data
     * Note: This is limited compared to on-chain queries
     */
    execute(storage: PrivateMetadataStorage, references: StoredPrivateData[]): Promise<StoredPrivateData[]>;
}
/**
 * Calculate storage cost estimate
 */
declare function estimateStorageCost(dataSize: number, provider: 'ipfs' | 'arweave'): {
    cost: bigint;
    currency: string;
};
/**
 * Create a privacy manifest for transparency
 */
interface PrivacyManifest {
    dataTypes: string[];
    encryptionMethod: 'elgamal' | 'aes256';
    storageLocation: 'ipfs' | 'arweave' | 'on-chain';
    retentionPeriod?: number;
    accessControl: 'owner-only' | 'public-read' | 'permissioned';
}
declare function createPrivacyManifest(dataTypes: string[], options?: Partial<PrivacyManifest>): PrivacyManifest;

/**
 * Feature Gate Detector
 *
 * Runtime detection of Solana feature gates to determine which native
 * programs and features are available on the current network.
 *
 * This module specifically tracks feature gates
 * and provides caching to minimize RPC calls.
 */

/**
 * Known feature gate addresses
 */
declare const FEATURE_GATES: {
    /** Confidential transfers feature (placeholder) */
    readonly CONFIDENTIAL_TRANSFERS: Address<"11111111111111111111111111111111">;
    /** Token-2022 program (placeholder) */
    readonly TOKEN_2022: Address<"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb">;
};
interface FeatureStatus {
    /** Whether the feature is activated */
    activated: boolean;
    /** When the status was last checked */
    lastChecked: number;
    /** Optional activation slot if known */
    activationSlot?: bigint;
    /** Error if status check failed */
    error?: string;
}
/**
 * Check if a feature gate is activated on the current network
 *
 * @param connection - Solana connection
 * @param featureGate - Feature gate public key to check
 * @returns Feature activation status
 */
declare function checkFeatureGate(rpc: Rpc<GetAccountInfoApi>, featureGate: Address): Promise<FeatureStatus>;
/**
 * Clear the feature gate cache
 * Useful for testing or forcing fresh checks
 */
declare function clearFeatureGateCache(): void;

export { type AggregatedReputation, type ApiResolverConfig, type ApproveDeliveryParams, type ArbitrateDisputeParams, type ArbitratorDecision, BaseModule, BaseReputationAdapter, type BatchFetchConfig, type BatchProgressCallback, CircuitBreaker, ClientEncryptionService, ContentStorageResult, type CreateEscrowParams, DEFAULT_IPFS_CONFIG, DEFAULT_RETRY_CONFIG, type DeliverySubmittedEvent, type DisputeFiledEvent, type DisputeResolvedEvent, type EscrowCompletedEvent, type EscrowCreatedEvent, EscrowModule, EscrowStatus, ExtendedRpcApi, ExternalIdResolver, FEATURE_GATES, FallbackHandler, type FeatureStatus, type FileDisputeParams, type FundingResult, type FundingStrategyOptions, GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, type GhostProtectEscrow, type GhostSlashedEvent, type GhostStakedEvent, type GhostUnstakedEvent, INSTRUCTION_MAPPINGS, IPFSClient, IPFSConfig, IPFSContentMetadata, IPFSError, IPFSErrorHandler, IPFSOperationError, IPFSOperationResult, IPFSProvider, IPFSUploadOptions, IPFSUtils, InstructionValidationError, LocalStorageProvider, MetricVisibility, MultiSourceAggregator, type PrivacyManifest, PrivacyMode, PrivacySettings, PrivateDataQuery, type PrivateDataReference, PrivateMetadataStorage, ReputationSource, type ReputationSourceAdapter, type ReputationSourceConfig, type ReputationTagsUpdatedEvent, RetryHandler, RpcClient, ScoreRange, type SignatureInfo, SlashReason, type SourceReputationData, type SourceScoreBreakdown, type StorageProvider, type StoredPrivateData, type SubmitDeliveryParams, TEST_IPFS_CONFIG, type TagDecayAppliedEvent, type TagScore, VisibleReputation, WalletFundingService, type X402IndexerConfig, type X402PaymentData, X402TransactionIndexer, batchGetAccounts, batchGetAccountsWithRetry, batchGetAndMap, batchGetExistingAccounts, calculateVisibleScore, canViewerAccess, checkFeatureGate, clearFeatureGateCache, createAccountMismatchError, createBatchFetcher, createIPFSErrorHandler, createIPFSUtils, createMetadataUri, createPrivacyManifest, createTestIPFSConfig, debugInstructionCall, defaultFundingService, determineStorageMethod, enhanceErrorMessage, ensureMinimumBalance, estimateStorageCost, filterMetricsByVisibility, fundWallet, generateAccountValidationError, getAccountRequirements, getApproveDeliveryInstruction, getArbitrateDisputeInstruction, getClaimGhostInstruction, getCreateDidDocumentInstructionAsync, getCreateEscrowInstructionAsync, getDeactivateDidDocumentInstructionAsync, getDefaultMetricVisibility, getFileDisputeInstruction, getGhostProtectEscrowDecoder, getInitializeStakingConfigInstructionAsync, getInstructionMapping, getPDAAccounts, getRangeDisplayString, getRegisterAgentInstructionAsync, getReputationTier, getRequiredSigners, getResolveDidDocumentInstructionAsync, getScoreRange, getSlashStakeInstructionAsync, getStakeGhostInstructionAsync, getSubmitDeliveryInstruction, getTierDisplayName, getUnstakeGhostInstructionAsync, getUpdateDidDocumentInstructionAsync, getUpdateReputationTagsInstructionAsync, getWritableAccounts, isIPFSError, isKnownInstruction, validateInstructionAccounts, validatePrivacySettings, withIPFSErrorHandling };