import * as viem from 'viem';
import { PublicClient, WalletClient, Address, Chain, Account, Hash } from 'viem';
export { Address, Hash, Log, PublicClient, TransactionReceipt, WalletClient } from 'viem';
import { ContractAddresses, AgentData, TaskData } from '@covenant/shared-types';
export { AgentData, BASE_SEPOLIA_ADDRESSES, BidData, CollectiveData, ContractAddresses, PRIORITY_LEVEL, RECEIPT_TYPE, ReceiptData, TASK_STATUS, TaskData, TaskStatus } from '@covenant/shared-types';

/**
 * ERC-8004 Receipt type enum (mirrors on-chain ReceiptVerifier.ReceiptType)
 */
declare enum ReceiptType {
    TaskCompleted = 0,
    AgentVerified = 1,
    DisputeResolved = 2,
    InsuranceClaimed = 3,
    MilestoneReached = 4,
    ReputationUpdated = 5
}
/**
 * V2 Receipt data from ReceiptVerifier v2
 */
interface ReceiptDataV2 {
    receiptId: `0x${string}`;
    issuer: Address;
    counterparty: Address;
    receiptType: number;
    dataHash: `0x${string}`;
    timestamp: bigint;
    isValid: boolean;
}
/**
 * Insurance claim data
 */
interface InsuranceClaimData {
    claimant: Address;
    taskId: bigint;
    amount: bigint;
    paid: boolean;
    timestamp: bigint;
}
/**
 * Insurance pool member info
 */
interface MemberInfo {
    active: boolean;
    contributed: bigint;
}
/**
 * Dispute data from DisputeResolution
 */
interface DisputeData {
    taskId: bigint;
    filedBy: Address;
    bondAmount: bigint;
    votingEndsAt: bigint;
    resolved: boolean;
    workerWins: boolean;
    workerShare: bigint;
}
/**
 * V2 contract addresses
 */
interface V2ContractAddresses {
    AgentRegistry: Address;
    TaskEscrow: Address;
    ReceiptVerifier: Address;
    InsurancePool: Address;
    DisputeResolution: Address;
}
/**
 * SDK configuration
 */
interface CovenantConfig {
    /** Chain ID (84532 for Base Sepolia, 8453 for Base Mainnet) */
    chainId: number;
    /** Viem public client for reading */
    publicClient: PublicClient;
    /** Optional wallet client for writing */
    walletClient?: WalletClient;
    /** Custom contract addresses (optional - uses defaults if not provided) */
    contractAddresses?: PartialContractAddresses;
}
/**
 * V2 SDK configuration — extends base config with version selection
 */
interface CovenantConfigV2 extends CovenantConfig {
    /** SDK version — "v2" enables v2 contract methods */
    version: "v2";
    /** Custom v2 contract addresses (optional - uses defaults if not provided) */
    v2ContractAddresses?: Partial<V2ContractAddresses>;
}
/**
 * Partial contract addresses - only specify what you want to override
 */
interface PartialContractAddresses {
    AgentRegistry?: Address;
    TaskEscrow?: Address;
    ReceiptVerifier?: Address;
    OpenTaskMarket?: Address;
    ParallelTaskBatch?: Address;
    AgentCollective?: Address;
    AgentInsurance?: Address;
    DisputeArbitration?: Address;
    Groth16VerifierCapability?: Address;
    CapabilityVerifier?: Address;
    Groth16VerifierReputation?: Address;
    ReputationVerifier?: Address;
    COVENANTRouter?: Address;
    LitProtocolIntegration?: Address;
    AgentWallet?: Address;
}

/**
 * Default contract addresses by chain ID
 */
declare const DEFAULT_ADDRESSES: Record<number, ContractAddresses>;
/**
 * Default V2 contract addresses by chain ID
 */
declare const V2_ADDRESSES: Record<number, V2ContractAddresses>;
/**
 * Chain configurations
 */
declare const CHAIN_CONFIGS: {
    readonly 84532: {
        readonly chain: {
            readonly id: 84532;
            readonly name: "Base Sepolia";
            readonly nativeCurrency: {
                readonly name: "Ether";
                readonly symbol: "ETH";
                readonly decimals: 18;
            };
            readonly rpcUrls: {
                readonly default: {
                    readonly http: readonly ["https://sepolia.base.org"];
                };
            };
        };
    };
    readonly 8453: {
        readonly chain: {
            readonly id: 8453;
            readonly name: "Base";
            readonly nativeCurrency: {
                readonly name: "Ether";
                readonly symbol: "ETH";
                readonly decimals: 18;
            };
            readonly rpcUrls: {
                readonly default: {
                    readonly http: readonly ["https://mainnet.base.org"];
                };
            };
        };
    };
    readonly 31337: {
        readonly chain: {
            readonly id: 31337;
            readonly name: "Hardhat Local";
            readonly nativeCurrency: {
                readonly name: "Ether";
                readonly symbol: "ETH";
                readonly decimals: 18;
            };
            readonly rpcUrls: {
                readonly default: {
                    readonly http: readonly ["http://localhost:8545"];
                };
            };
        };
    };
};
/**
 * Chain configurations (legacy export)
 */
declare const CHAINS: {
    readonly baseSepolia: {
        readonly id: 84532;
        readonly name: "Base Sepolia";
        readonly nativeCurrency: {
            readonly name: "Ether";
            readonly symbol: "ETH";
            readonly decimals: 18;
        };
        readonly rpcUrls: {
            readonly default: {
                readonly http: readonly ["https://sepolia.base.org"];
            };
        };
        readonly blockExplorers: {
            readonly default: {
                readonly name: "Basescan";
                readonly url: "https://sepolia.basescan.org";
            };
        };
        readonly testnet: true;
    };
    readonly base: {
        readonly id: 8453;
        readonly name: "Base";
        readonly nativeCurrency: {
            readonly name: "Ether";
            readonly symbol: "ETH";
            readonly decimals: 18;
        };
        readonly rpcUrls: {
            readonly default: {
                readonly http: readonly ["https://mainnet.base.org"];
            };
        };
        readonly blockExplorers: {
            readonly default: {
                readonly name: "Basescan";
                readonly url: "https://basescan.org";
            };
        };
    };
};
/**
 * Get contract addresses for a chain ID with optional overrides
 */
declare function getContractAddresses(chainId: number, overrides?: Partial<ContractAddresses>): ContractAddresses;
/**
 * Check if contracts are deployed on a chain
 */
declare function isDeployed(chainId: number): boolean;
/**
 * Get V2 contract addresses for a chain ID with optional overrides
 */
declare function getV2ContractAddresses(chainId: number, overrides?: Partial<V2ContractAddresses>): V2ContractAddresses;

interface V5Config {
    chainId: number;
    publicClient: PublicClient;
    walletClient?: WalletClient;
    contractAddresses?: Partial<ContractAddresses>;
}
declare class CovenantSDKV5 {
    protected publicClient: PublicClient;
    protected walletClient?: WalletClient;
    protected chain: Chain;
    protected account?: Account;
    private addresses;
    constructor(config: V5Config);
    private requireWallet;
    getAddresses(): ContractAddresses;
    waitForTransaction(hash: Hash): Promise<viem.TransactionReceipt>;
    createStream(payee: Address, ratePerSecond: bigint, duration: number): Promise<Hash>;
    withdrawStream(streamId: bigint): Promise<Hash>;
    cancelStream(streamId: bigint): Promise<Hash>;
    getStream(streamId: bigint): Promise<any>;
    streamCount(): Promise<bigint>;
    claimableAmount(streamId: bigint): Promise<bigint>;
    settleReceipt(payer: Address, payee: Address, amount: bigint, nonce: bigint, payerSignature: `0x${string}`): Promise<Hash>;
    batchSettleReceipts(payers: Address[], payees: Address[], amounts: bigint[], nonces: bigint[], payerSignatures: `0x${string}`[]): Promise<Hash>;
    receiptCount(): Promise<bigint>;
    batchCount(): Promise<bigint>;
    createDispute(taskId: bigint, evidenceHash: `0x${string}`): Promise<Hash>;
    stakeForDispute(disputeId: bigint, amount: bigint): Promise<Hash>;
    settleDispute(disputeId: bigint): Promise<Hash>;
    submitRuling(disputeId: bigint, ruling: number, splitBps: number, arbiterSignature: `0x${string}`): Promise<Hash>;
    getDispute(disputeId: bigint): Promise<any>;
    disputeCount(): Promise<bigint>;
    arbiter(): Promise<Address>;
    attest(subject: Address, schemaHash: `0x${string}`, dataHash: `0x${string}`, expiresAt: number): Promise<Hash>;
    attestBatch(subjects: Address[], schemaHash: `0x${string}`, dataHashes: `0x${string}`[], expiresAt: number): Promise<Hash>;
    verifyAttestation(attestationId: `0x${string}`): Promise<{
        valid: boolean;
        attestation: any;
    }>;
    attestationCount(): Promise<bigint>;
    getAgentAttestations(agent: Address): Promise<`0x${string}`[]>;
    registerIssuer(issuer: Address, name: string): Promise<Hash>;
    registerSchema(schemaHash: `0x${string}`, name: string): Promise<Hash>;
    revokeAttestation(attestationId: `0x${string}`): Promise<Hash>;
    isIssuer(address: Address): Promise<boolean>;
    schemaExists(schemaHash: `0x${string}`): Promise<boolean>;
    propose(target: Address, callData: `0x${string}`, descriptionHash: `0x${string}`, votingPeriod: number): Promise<Hash>;
    submitVotes(proposalId: bigint, forVotes: bigint, againstVotes: bigint, guardianSignature: `0x${string}`): Promise<Hash>;
    executeProposal(proposalId: bigint): Promise<Hash>;
    vetoProposal(proposalId: bigint): Promise<Hash>;
    emergencyPause(target: Address, paused: boolean): Promise<Hash>;
    getProposal(proposalId: bigint): Promise<any>;
    proposalCount(): Promise<bigint>;
    quorum(): Promise<bigint>;
    guardian(): Promise<Address>;
    vetoer(): Promise<Address>;
    isPaused(target: Address): Promise<boolean>;
    setGuardian(newGuardian: Address): Promise<Hash>;
    setVetoer(newVetoer: Address): Promise<Hash>;
    setQuorum(newQuorum: bigint): Promise<Hash>;
    joinPool(amount: bigint): Promise<Hash>;
    fileClaim(taskId: bigint, amount: bigint): Promise<Hash>;
    voteOnClaim(claimId: bigint, inFavor: boolean): Promise<Hash>;
    approveClaim(claimId: bigint): Promise<Hash>;
    payClaim(claimId: bigint): Promise<Hash>;
    withdrawPool(): Promise<Hash>;
    getPoolBalance(): Promise<bigint>;
    getMemberInfo(address: Address): Promise<any>;
    getClaim(claimId: bigint): Promise<any>;
    claimCount(): Promise<bigint>;
    memberCount(): Promise<bigint>;
    createTraining(title: string, price: bigint): Promise<Hash>;
    enroll(trainingId: bigint, price: bigint): Promise<Hash>;
    getTraining(trainingId: bigint): Promise<any>;
    trainingCount(): Promise<bigint>;
    platformFeeBps(): Promise<bigint>;
    feeRecipient(): Promise<Address>;
    depositToGrants(amount: bigint): Promise<Hash>;
    applyGrant(amount: bigint): Promise<Hash>;
    voteGrant(grantId: bigint, inFavor: boolean): Promise<Hash>;
    disburseGrant(grantId: bigint): Promise<Hash>;
    getGrant(grantId: bigint): Promise<any>;
    grantCount(): Promise<bigint>;
    treasury(): Promise<bigint>;
    votingPeriod(): Promise<bigint>;
    requestRevision(taskId: bigint, feedbackHash: string): Promise<Hash>;
    submitRevision(taskId: bigint, newHash: `0x${string}`): Promise<Hash>;
    getRevisionCount(taskId: bigint): Promise<bigint>;
    getLatestRevision(taskId: bigint): Promise<any>;
    getRevision(taskId: bigint, revisionNumber: bigint): Promise<any>;
    revisionAllowed(taskId: bigint): Promise<boolean>;
    taskClient(taskId: bigint): Promise<Address>;
    setTaskClient(taskId: bigint, client: Address): Promise<Hash>;
    setMaxRevisions(taskId: bigint, max: bigint): Promise<Hash>;
    setRevisionAllowed(taskId: bigint, allowed: boolean): Promise<Hash>;
    defaultMaxRevisions(): Promise<bigint>;
    createBatch(workers: Address[], payments: bigint[], deadlines: bigint[], descriptionHashes: `0x${string}`[], aggregationSpec: `0x${string}`): Promise<Hash>;
    aggregateResults(batchId: bigint): Promise<Hash>;
    getBatch(batchId: bigint): Promise<any>;
    batchCounter(): Promise<bigint>;
    createCollective(minContribution: bigint, maxMembers: bigint): Promise<Hash>;
    joinCollective(collectiveId: bigint, amount: bigint): Promise<Hash>;
    launchCollectiveTask(collectiveId: bigint, worker: Address, payment: bigint, deadline: bigint, descriptionHash: `0x${string}`): Promise<Hash>;
    getCollective(collectiveId: bigint): Promise<{
        memberCount: bigint;
        totalFund: bigint;
        launched: boolean;
    }>;
    collectiveCounter(): Promise<bigint>;
    createTaskERC20(worker: Address, token: Address, amount: bigint, deadline: bigint): Promise<Hash>;
    verifyTask(taskId: bigint, success: boolean): Promise<Hash>;
    multiTokenTaskCount(): Promise<bigint>;
    isAcceptedToken(token: Address): Promise<boolean>;
    tokenFee(token: Address): Promise<bigint>;
    setAcceptedToken(token: Address, accepted: boolean): Promise<Hash>;
    multicall(calls: Array<{
        target: Address;
        data: `0x${string}`;
        value: bigint;
    }>): Promise<Hash>;
    registerAndCreateTask(agentRegistry: Address, taskEscrow: Address, name: string, capabilities: string[], worker: Address, payment: bigint, deadline: bigint, descriptionHash: string): Promise<Hash>;
}

declare class CovenantSDK {
    protected publicClient: PublicClient;
    protected walletClient?: WalletClient;
    private addresses;
    protected chain: Chain;
    protected account?: Account;
    constructor(config: CovenantConfig);
    getAgent(address: Address): Promise<AgentData>;
    getAgentCount(): Promise<bigint>;
    isRegistered(address: Address): Promise<boolean>;
    findAgents(capability: string, minReputation?: number, limit?: number): Promise<Address[]>;
    getAllAgents(offset?: number, limit?: number): Promise<Address[]>;
    registerAgent(stake: bigint, metadataRoot: `0x${string}`): Promise<Hash>;
    getTask(taskId: bigint): Promise<TaskData>;
    getTaskCount(): Promise<bigint>;
    createTask(worker: Address, amount: bigint, deadline: number, metaHash: `0x${string}`): Promise<Hash>;
    submitWork(taskId: bigint, deliverableHash: `0x${string}`): Promise<Hash>;
    completeTask(taskId: bigint, clientSignature: `0x${string}`): Promise<Hash>;
    disputeTask(taskId: bigint): Promise<Hash>;
    cancelTask(taskId: bigint): Promise<Hash>;
    fundTask(taskId: bigint, amount: bigint): Promise<Hash>;
    failTask(taskId: bigint, reason: `0x${string}`): Promise<Hash>;
    waitForTransaction(hash: Hash): Promise<viem.TransactionReceipt>;
    getAddresses(): ContractAddresses;
    protected requireWallet(): void;
    private parseAgentData;
    private parseTaskData;
    private mapV5Status;
}

export { CHAINS, CHAIN_CONFIGS, type CovenantConfig, type CovenantConfigV2, CovenantSDK, CovenantSDKV5, DEFAULT_ADDRESSES, type DisputeData, type InsuranceClaimData, type MemberInfo, type PartialContractAddresses, type ReceiptDataV2, ReceiptType, type V2ContractAddresses, V2_ADDRESSES, getContractAddresses, getV2ContractAddresses, isDeployed };