import type { CoprocessorConfig, CoprocessorEvent, FhevmContractName, FhevmPublicDecryptOptions, FhevmTransactionHCUInfo, FhevmTypeEuint, FhevmUserDecryptOptions } from "@fhevm/mock-utils";
import { FhevmHandleCoder, relayer } from "@fhevm/mock-utils";
import type { HandleContractPair, KmsDelegatedUserDecryptEIP712Type, KmsUserDecryptEIP712Type, PublicDecryptResults, RelayerEncryptedInput, UserDecryptResults } from "@zama-fhe/relayer-sdk/node";
import type { ethers } from "ethers";
import type { FhevmContractError } from "./internal/errors/FhevmContractError";
export { FhevmType, FhevmTypeEuint, FhevmUserDecryptOptions, FhevmKeypair, FhevmUserDecryptValidity, FhevmTransactionHCUInfo, CoprocessorConfig, } from "@fhevm/mock-utils";
export interface HardhatFhevmRuntimeEnvironment {
    readonly isMock: boolean;
    readonly debugger: HardhatFhevmRuntimeDebugger;
    initializeCLIApi(): Promise<void>;
    parseCoprocessorEvents(logs: (ethers.EventLog | ethers.Log)[] | null | undefined): CoprocessorEvent[];
    computeTransactionHCU(transactionReceipt: ethers.TransactionReceipt): FhevmTransactionHCUInfo;
    assertCoprocessorInitialized(contract: ethers.AddressLike, contractName?: string): Promise<void>;
    getCoprocessorConfig(contractAddress: string): Promise<CoprocessorConfig>;
    getRelayerMetadata(): Promise<relayer.RelayerMetadata>;
    revertedWithCustomErrorArgs(contractName: FhevmContractName, customErrorName: string): [{
        interface: ethers.Interface;
    }, string];
    tryParseFhevmError(e: unknown, options?: {
        encryptedInput?: RelayerEncryptedInput;
        out?: "stderr" | "stdout" | "console";
    }): Promise<FhevmContractError | undefined>;
    createEncryptedInput(contractAddress: string, userAddress: string): RelayerEncryptedInput;
    createEIP712(publicKey: string, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number): KmsUserDecryptEIP712Type;
    createDelegatedUserDecryptEIP712(publicKey: string, contractAddresses: string[], delegatorAddress: string, startTimestamp: number, durationDays: number): KmsDelegatedUserDecryptEIP712Type;
    generateKeypair(): {
        publicKey: string;
        privateKey: string;
    };
    userDecrypt(handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number): Promise<UserDecryptResults>;
    delegatedUserDecrypt(handleContractPairs: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], delegatorAddress: string, delegateAddress: string, startTimestamp: number, durationDays: number): Promise<UserDecryptResults>;
    publicDecrypt(handles: (string | Uint8Array)[]): Promise<PublicDecryptResults>;
    userDecryptEbool(handleBytes32: string, contractAddress: ethers.AddressLike, user: ethers.Signer, options?: FhevmUserDecryptOptions): Promise<boolean>;
    publicDecryptEbool(handleBytes32: string, options?: FhevmPublicDecryptOptions): Promise<boolean>;
    /**
     * Decrypts a single FHE-encrypted unsigned integer of type `fhevmType` represented by a bytes32 handle.
     *
     * The function only succeeds if the user and the contract both have been granted FHE access to the handle.
     *
     * To grant FHE access, call FHE permission Solidity methods such as `FHE.allow(handle, account)`
     * for both the user and the contract address.
     *
     * @param fhevmType - The expected `FhevmTypeEuint` enum value, used to validate that the handle’s encrypted type matches the requested decryption type.
     * @param handleBytes32 - A 32-byte on-chain handle referencing the encrypted data.
     * @param contractAddress - An contract address represented as an `ethers.AddressLike` that has FHE permission to access the handle.
     * @param user - An `ethers.Signer` user account representing the user attempting to decrypt the value. This signer must have FHE permission to access the handle.
     * @param options - Optional decryption parameters including:
     *   - `instance`: A custom `FhevmInstance` to use for decryption in place of the default one.
     *   - `keypair`: A public/private keypair to use for decryption. If not provided, the function will automatically generate one using `generateKeypair()`.
     *   - `validity`: A time-bound validity constraint for the decryption operation
     *
     * @returns A Promise that resolves to the decrypted value as a `bigint`.
     *
     * @throws Will throw if:
     * - The user has not been granted FHE decryption access to the handle.
     * - The contract at `contractAddress` does not have decryption permission.
     * - The handle is invalid or unavailable in the contract storage.
     *
     * @example
     * ```ts
     * const result = await userDecryptEuint(
     *   encryptedEuint,
     *   "0xabc123...handle",
     *   "0xContractAddress",
     *   signer,
     *   {
     *     keypair: {
     *       publicKey: "0x...",
     *       privateKey: "0x..."
     *     }
     *   }
     * );
     * console.log(result); // e.g., 123n
     * ```
     */
    userDecryptEuint(fhevmType: FhevmTypeEuint, handleBytes32: string, contractAddress: ethers.AddressLike, user: ethers.Signer, options?: FhevmUserDecryptOptions): Promise<bigint>;
    publicDecryptEuint(fhevmType: FhevmTypeEuint, handleBytes32: string, options?: FhevmPublicDecryptOptions): Promise<bigint>;
    userDecryptEaddress(handleBytes32: string, contractAddress: ethers.AddressLike, user: ethers.Signer, options?: FhevmUserDecryptOptions): Promise<string>;
    publicDecryptEaddress(handleBytes32: string, options?: FhevmPublicDecryptOptions): Promise<string>;
}
export interface HardhatFhevmRuntimeDebugger {
    createHandleCoder(): FhevmHandleCoder;
    createDecryptionSignatures(handlesBytes32Hex: string[], clearTextValues: (bigint | string | boolean)[]): Promise<string[]>;
    decryptEbool(handleBytes32: ethers.BigNumberish): Promise<boolean>;
    decryptEuint(fhevmType: FhevmTypeEuint, handleBytes32: ethers.BigNumberish): Promise<bigint>;
    decryptEaddress(handleBytes32: ethers.BigNumberish): Promise<`0x${string}`>;
}
//# sourceMappingURL=types.d.ts.map