import { type Address, type Chain, type HashTypedDataParameters, type Hex, type PublicClient, type SignableMessage, type SignedAuthorization, type SignedAuthorizationList, type TypedData, type TypedDataDefinition, type TypedDataDomain } from 'viem';
import { type UserOperation } from 'viem/account-abstraction';
import type { ResolvedSessionSignerSet } from '../modules/validators/smart-sessions';
import { type IntentOp, type IntentRoute } from '../orchestrator';
import { type AuxiliaryFunds, type OriginSignature, type SettlementLayer, type SignatureMode } from '../orchestrator/types';
import type { Call, CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData, SessionSignerSet, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types';
type InternalSignerSet = Exclude<SignerSet, SessionSignerSet> | ResolvedSessionSignerSet;
declare function resolveSignatureMode(config: RhinestoneConfig, signers: SignerSet | undefined, sourceChains: Chain[] | undefined, targetChain: Chain): Promise<SignatureMode>;
declare function resolveSessionForChain(signers: SessionSignerSet, chainId: number): {
    session: Session;
    enableData?: SessionEnableData;
    verifyExecutions?: boolean;
};
interface UserOperationResult {
    type: 'userop';
    hash: Hex;
    chain: number;
}
interface TransactionResult {
    type: 'intent';
    id: bigint;
    sourceChains?: number[];
    targetChain: number;
}
interface PreparedTransactionData {
    intentRoute: IntentRoute;
    intentInput: unknown;
    transaction: Transaction;
}
interface PreparedUserOperationData {
    userOperation: UserOperation;
    hash: Hex;
    transaction: UserOperationTransaction;
}
interface SignedTransactionData extends PreparedTransactionData {
    originSignatures: OriginSignature[];
    destinationSignature: Hex;
    targetExecutionSignature: Hex | undefined;
}
interface SignedUserOperationData extends PreparedUserOperationData {
    signature: Hex;
}
declare function prepareTransaction(config: RhinestoneConfig, transaction: Transaction): Promise<PreparedTransactionData>;
declare function prepareUserOperation(config: RhinestoneConfig, transaction: UserOperationTransaction): Promise<PreparedUserOperationData>;
declare function resolveCallInputs(inputs: CallInput[] | undefined, config: RhinestoneConfig, chain: Chain, accountAddress: Address): Promise<CalldataInput[]>;
declare function getTransactionMessages(config: RhinestoneConfig, preparedTransaction: PreparedTransactionData): {
    origin: TypedDataDefinition[];
    destination: TypedDataDefinition;
};
declare function signTransaction(config: RhinestoneConfig, preparedTransaction: PreparedTransactionData): Promise<SignedTransactionData>;
declare function getTargetExecutionSignature(config: RhinestoneConfig, intentOp: IntentOp, targetChain: Chain, signers: SignerSet | undefined): Promise<`0x${string}` | undefined>;
declare function signUserOperation(config: RhinestoneConfig, preparedUserOperation: PreparedUserOperationData): Promise<SignedUserOperationData>;
declare function signAuthorizations(config: RhinestoneConfig, preparedTransaction: PreparedTransactionData): Promise<SignedAuthorization[]>;
declare function signMessage(config: RhinestoneConfig, message: SignableMessage, chain: Chain, signers: SignerSet | undefined): Promise<`0x${string}`>;
declare function signTypedData<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(config: RhinestoneConfig, parameters: HashTypedDataParameters<typedData, primaryType>, chain: Chain, signers: SignerSet | undefined, options?: {
    skipErc6492?: boolean;
}): Promise<`0x${string}`>;
declare function signAuthorizationsInternal(config: RhinestoneConfig, data: IntentRoute | UserOperation): Promise<SignedAuthorization[]>;
declare function submitTransaction(config: RhinestoneConfig, signedTransaction: SignedTransactionData, authorizations: SignedAuthorizationList, dryRun?: boolean): Promise<TransactionResult>;
declare function submitUserOperation(config: RhinestoneConfig, signedUserOperation: SignedUserOperationData): Promise<UserOperationResult>;
declare function getTokenRequests(targetChain: Chain, initialTokenRequests: TokenRequest[] | undefined): TokenRequest[];
declare function getIntentAccount(config: RhinestoneConfig, eip7702InitSignature: Hex | undefined, account: {
    setupOps?: {
        to: Address;
        data: Hex;
    }[];
} | undefined): {
    address: `0x${string}`;
    accountType: "ERC7579" | "EOA";
    setupOps: {
        to: Address;
        data: Hex;
    }[];
    delegations: {
        0: {
            contract: `0x${string}`;
        };
    } | undefined;
};
declare function prepareTransactionAsIntent(config: RhinestoneConfig, sourceChains: Chain[] | undefined, targetChain: Chain, callInputs: CalldataInput[], gasLimit: bigint | undefined, tokenRequests: TokenRequest[], recipientInput: RhinestoneAccountConfig | Address | undefined, sponsored: Sponsorship | undefined, eip7702InitSignature: Hex | undefined, settlementLayers: SettlementLayer[] | undefined, sourceAssets: SourceAssetInput | undefined, feeAsset: Address | TokenSymbol | undefined, lockFunds: boolean | undefined, auxiliaryFunds: AuxiliaryFunds | undefined, account: {
    setupOps?: {
        to: Address;
        data: Hex;
    }[];
} | undefined, signers: SignerSet | undefined, sourceCalls: Record<number, CallInput[]> | undefined): Promise<{
    intentRoute: IntentRoute;
    intentInput: any;
}>;
declare function signIntent(config: RhinestoneConfig, intentOp: IntentOp, targetChain: Chain, signers?: SignerSet, targetExecution?: boolean): Promise<{
    originSignatures: OriginSignature[];
    destinationSignature: `0x${string}`;
}>;
declare function submitIntentInternal(config: RhinestoneConfig, sourceChains: Chain[] | undefined, targetChain: Chain, intentOp: IntentOp, originSignatures: OriginSignature[], destinationSignature: Hex, targetExecutionSignature: Hex | undefined, authorizations: SignedAuthorizationList, dryRun: boolean, intentInput?: unknown): Promise<TransactionResult>;
declare function getValidatorAccount(config: RhinestoneConfig, signers: SignerSet | undefined, publicClient: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">> | null | undefined>;
declare function parseCalls(calls: CalldataInput[], chainId: number): Call[];
declare function hashErc7739TypedDataForSolady({ domain, types, primaryType, message, verifierDomain, }: {
    domain: TypedDataDomain;
    types: TypedData;
    primaryType: string;
    message: Record<string, unknown>;
    verifierDomain: {
        name: string;
        version: string;
        chainId: number;
        verifyingContract: Address;
        salt: Hex;
    };
}): Hex;
export { prepareTransaction, getTransactionMessages, signTransaction, signAuthorizations, signAuthorizationsInternal, signMessage, signTypedData, submitTransaction, prepareUserOperation, signUserOperation, submitUserOperation, signIntent, prepareTransactionAsIntent, submitIntentInternal, getValidatorAccount, parseCalls, getTokenRequests, resolveCallInputs, getIntentAccount, getTargetExecutionSignature, hashErc7739TypedDataForSolady, resolveSessionForChain, resolveSignatureMode, };
export type { InternalSignerSet, IntentRoute, TransactionResult, PreparedTransactionData, PreparedUserOperationData, SignedTransactionData, SignedUserOperationData, UserOperationResult, };
//# sourceMappingURL=utils.d.ts.map