import type { Account, Address, Chain, HashTypedDataParameters, Hex, SignableMessage, SignedAuthorizationList, TypedData, TypedDataDefinition } from 'viem';
import type { UserOperationReceipt } from 'viem/account-abstraction';
import { deployStandaloneWithEoa as deployStandaloneWithEoaInternal } from './accounts';
import { walletClientToAccount, wrapParaAccount } from './accounts/walletClient';
import { deployAccountsForOwners } from './actions/deployment';
import { type TransactionResult, type TransactionStatus, type UserOperationResult } from './execution';
import { type BatchPermit2Result, checkERC20AllowanceDirect, getPermit2Address, type MultiChainPermit2Config, type MultiChainPermit2Result, signPermit2Batch, signPermit2Sequential } from './execution/permit2';
import { type IntentRoute, type PreparedTransactionData, type PreparedUserOperationData, type SignedTransactionData, type SignedUserOperationData } from './execution/utils';
import { MULTI_FACTOR_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS } from './modules';
import { type SessionDetails } from './modules/validators/smart-sessions';
import { type AppFee, type AppFeeBalances, type AppFeeRate, type ApprovalRequired, type AuxiliaryFunds, getAllSupportedChainsAndTokens, getSupportedTokens, getTokenAddress, getTokenDecimals, type IntentInput, type IntentOp, type IntentOpStatus, type Portfolio, type SettlementLayer, type SignedIntentOp, type SplitIntentsInput, type SplitIntentsResult, type TokenRequirements, type WrapRequired } from './orchestrator';
import type { AccountProviderConfig, AccountType, BundlerConfig, Call, CallInput, ChainSessionConfig, MultiFactorValidatorConfig, OwnableValidatorConfig, OwnerSet, PaymasterConfig, Permit2ClaimPolicy, Policy, ProviderConfig, Recovery, RhinestoneAccountConfig, RhinestoneConfig, RhinestoneSDKConfig, Session, SignerSet, TokenRequest, TokenSymbol, Transaction, UniversalActionPolicyParamCondition, UserOperationTransaction, WebauthnValidatorConfig } from './types';
interface RhinestoneAccount {
    config: RhinestoneAccountConfig;
    deploy: (chain: Chain, params?: {
        session?: Session;
        sponsored?: boolean;
    }) => Promise<boolean>;
    isDeployed: (chain: Chain) => Promise<boolean>;
    setup: (chain: Chain) => Promise<boolean>;
    deployStandaloneWithEoa: (chain: Chain, config: RhinestoneAccountConfig, deployer: Account) => Promise<void>;
    getInitData(): {
        factory: Address;
        factoryData: Hex;
    };
    signEip7702InitData: () => Promise<Hex>;
    prepareTransaction: (transaction: Transaction) => Promise<PreparedTransactionData>;
    getTransactionMessages: (preparedTransaction: PreparedTransactionData) => {
        origin: TypedDataDefinition[];
        destination: TypedDataDefinition;
    };
    signTransaction: (preparedTransaction: PreparedTransactionData) => Promise<SignedTransactionData>;
    signAuthorizations: (preparedTransaction: PreparedTransactionData) => Promise<SignedAuthorizationList>;
    signMessage: (message: SignableMessage, chain: Chain, signers: SignerSet | undefined) => Promise<Hex>;
    signTypedData: <typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(parameters: HashTypedDataParameters<typedData, primaryType>, chain: Chain, signers: SignerSet | undefined) => Promise<Hex>;
    submitTransaction: (signedTransaction: SignedTransactionData, authorizations?: SignedAuthorizationList, dryRun?: boolean) => Promise<TransactionResult>;
    sendTransaction: (transaction: Transaction) => Promise<TransactionResult>;
    prepareUserOperation: (transaction: UserOperationTransaction) => Promise<PreparedUserOperationData>;
    signUserOperation: (preparedUserOperation: PreparedUserOperationData) => Promise<SignedUserOperationData>;
    submitUserOperation: (signedUserOperation: SignedUserOperationData) => Promise<UserOperationResult>;
    sendUserOperation: (transaction: UserOperationTransaction) => Promise<UserOperationResult>;
    waitForExecution(result: TransactionResult, acceptsPreconfirmations?: boolean): Promise<TransactionStatus>;
    waitForExecution(result: UserOperationResult, acceptsPreconfirmations?: boolean): Promise<UserOperationReceipt>;
    getAddress: () => Address;
    getPortfolio: (onTestnets?: boolean) => Promise<Portfolio>;
    experimental_getSessionDetails: (sessions: Session[]) => Promise<SessionDetails>;
    experimental_isSessionEnabled: (session: Session) => Promise<boolean>;
    experimental_signEnableSession: (details: SessionDetails) => Promise<Hex>;
    getOwners: (chain: Chain) => Promise<{
        accounts: Address[];
        threshold: number;
    } | null>;
    getValidators: (chain: Chain) => Promise<Address[]>;
    getExecutors: (chain: Chain) => Promise<Address[]>;
    checkERC20Allowance: (tokenAddress: Address, chain: Chain) => Promise<bigint>;
}
/**
 * Initialize a Rhinestone account
 * Note: accounts are deployed onchain only when the first transaction is sent.
 * @param config Account config (e.g. implementation vendor, owner signers, smart sessions)
 * @returns account
 */
declare function createRhinestoneAccount(config: RhinestoneConfig): Promise<RhinestoneAccount>;
declare class RhinestoneSDK {
    private authProvider;
    private endpointUrl?;
    private provider?;
    private bundler?;
    private paymaster?;
    private useDevContracts?;
    private headers?;
    constructor(options: RhinestoneSDKConfig);
    createAccount(config: RhinestoneAccountConfig): Promise<RhinestoneAccount>;
    getIntentStatus(intentId: bigint): Promise<TransactionStatus & {
        status: IntentOpStatus["status"];
    }>;
    splitIntents(input: SplitIntentsInput): Promise<SplitIntentsResult>;
    /**
     * Get the integrator's accrued app-fee balance, as USD totals.
     *
     * App fees are earned by the integrator identified by this instance's API key
     * (project-scoped, not tied to any account) and valued in USD at the moment
     * each fee is collected, so the balance is not affected by later price
     * movements of the collected tokens.
     * @returns The withdrawable and pending app-fee balances in USD
     */
    getAppFeeBalances(): Promise<AppFeeBalances>;
}
export type { AccountProviderConfig, AccountType, AppFee, AppFeeBalances, AppFeeRate, ApprovalRequired, AuxiliaryFunds, BatchPermit2Result, BundlerConfig, Call, CallInput, ChainSessionConfig, IntentInput, IntentOp, IntentOpStatus, IntentRoute, MultiChainPermit2Config, MultiChainPermit2Result, MultiFactorValidatorConfig, OwnableValidatorConfig, OwnerSet, PaymasterConfig, Permit2ClaimPolicy, Policy, Portfolio, PreparedTransactionData, PreparedUserOperationData, ProviderConfig, Recovery, RhinestoneAccount, RhinestoneAccountConfig, Session, SettlementLayer, SignedIntentOp, SignedTransactionData, SignedUserOperationData, SignerSet, SplitIntentsInput, SplitIntentsResult, TokenRequest, TokenRequirements, TokenSymbol, Transaction, TransactionResult, UniversalActionPolicyParamCondition, UserOperationResult, WebauthnValidatorConfig, WrapRequired, };
export { checkERC20AllowanceDirect, createRhinestoneAccount, deployAccountsForOwners, deployStandaloneWithEoaInternal as deployStandaloneWithEoa, getAllSupportedChainsAndTokens, getPermit2Address, getSupportedTokens, getTokenAddress, getTokenDecimals, MULTI_FACTOR_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, RhinestoneSDK, SMART_SESSION_EMISSARY_ADDRESS, signPermit2Batch, signPermit2Sequential, WEBAUTHN_VALIDATOR_ADDRESS, walletClientToAccount, wrapParaAccount, };
//# sourceMappingURL=index.d.ts.map