import type { Address } from 'abitype';
import type { Block, BlockTag } from '../../types/block.js';
import type { FeeValuesLegacy } from '../../types/fee.js';
import type { Hash, Hex } from '../../types/misc.js';
import type { RpcTransactionReceipt } from '../../types/rpc.js';
import type { AccessList, TransactionBase as TransactionBase_, TransactionReceipt, TransactionRequestBase as TransactionRequestBase_, TransactionSerializableBase } from '../../types/transaction.js';
export type { SuaveWallet, SuaveProvider } from './wallet.js';
export declare enum SuaveTxRequestTypes {
    Legacy = "0x0",
    ConfidentialRequest = "0x43"
}
export declare enum SuaveTxTypes {
    ConfidentialRecord = "0x42",
    Suave = "0x50"
}
declare const AllSuaveTypes: {
    ConfidentialRecord: SuaveTxTypes.ConfidentialRecord;
    Suave: SuaveTxTypes.Suave;
    Legacy: SuaveTxRequestTypes.Legacy;
    ConfidentialRequest: SuaveTxRequestTypes.ConfidentialRequest;
};
export type SuaveTxType = `${(typeof AllSuaveTypes)[keyof typeof AllSuaveTypes]}`;
export type SuaveTxRequestType = `${(typeof SuaveTxRequestTypes)[keyof typeof SuaveTxRequestTypes]}`;
type ConfidentialOverrides = {
    kettleAddress?: Address;
    isEIP712?: boolean;
};
type ConfidentialComputeRequestOverrides = ConfidentialOverrides & {
    confidentialInputs?: Hex;
};
type ConfidentialComputeRecordOverrides = ConfidentialOverrides & {
    confidentialInputsHash?: Hash;
};
export type SuaveBlockOverrides = {};
export type SuaveTransactionReceiptOverrides = Partial<ConfidentialOverrides> & {
    confidentialComputeRequest: ConfidentialComputeRecord | null;
    confidentialComputeResult: Hex | null;
};
type FeeValues<TQuantity> = Omit<FeeValuesLegacy<TQuantity>, 'gasPrice'> & {
    gasPrice?: TQuantity;
};
type TransactionBase<TQuantity, TIndex, TType, TPending extends boolean> = TransactionBase_<TQuantity, TIndex, TPending> & FeeValues<TQuantity> & {
    accessList?: AccessList;
    chainId: TIndex;
    type: TType;
};
type TransactionRequestBase<TQuantity, TIndex, TType> = Omit<TransactionRequestBase_<TQuantity, TIndex>, 'from'> & FeeValues<TQuantity> & {
    accessList?: AccessList;
    chainId?: TIndex;
    type?: TType;
};
export type SuaveBlock<TIncludeTransactions extends boolean = boolean, TBlockTag extends BlockTag = BlockTag, TQuantity = bigint, TIndex = number> = Omit<Block<TQuantity, TIncludeTransactions, TBlockTag, TransactionSuave<TBlockTag extends 'pending' ? true : false, SuaveTxType, TQuantity, TIndex>>, 'sealFields'> & SuaveBlockOverrides;
export type SuaveRpcBlock<TBlockTag extends BlockTag = BlockTag, TIncludeTransactions extends boolean = boolean> = SuaveBlock<TIncludeTransactions, TBlockTag, Hex, Hex>;
export type TransactionSuave<TPending extends boolean = boolean, TType extends SuaveTxType = SuaveTxType, TQuantity = bigint, TIndex = number> = TransactionBase<TQuantity, TIndex, TType, TPending> & {
    requestRecord: ConfidentialComputeRecord<TPending, TQuantity, TIndex>;
    confidentialComputeResult: Hex;
    type: TType;
};
/** The type that interfaces with RPC endpoints.
 * Used for endpoints that returns transactions, such as `eth_getTransactionByHash`.
 * Also used when parsing transactions from this client before sending to RPC endpoints
 * and/or signing transactions.
 */
export type RpcTransactionSuave<TType extends SuaveTxType, TPending extends boolean = boolean> = TransactionSuave<TPending, TType, Hex, Hex>;
export type ConfidentialComputeRecord<TPending extends boolean = false, TQuantity = bigint, TIndex = number> = Omit<TransactionBase<TQuantity, TIndex, SuaveTxTypes.ConfidentialRecord, TPending>, 'blockHash' | 'transactionIndex' | 'blockNumber' | 'from'> & ConfidentialComputeRecordOverrides;
export type ConfidentialComputeRecordRpc<TPending extends boolean = false> = ConfidentialComputeRecord<TPending, Hex, Hex>;
export type TransactionRequestSuave<TQuantity = bigint, TIndex = number, TType extends SuaveTxRequestType = SuaveTxRequestType> = TransactionRequestBase<TQuantity, TIndex, TType> & ConfidentialComputeRequestOverrides & {
    from?: Address;
};
export type PreparedConfidentialRecord = Omit<ConfidentialComputeRecord, 'input' | 'typeHex' | 'hash' | 'r' | 's' | 'v'> & {
    data: Hex;
    to: Address;
    gasPrice: bigint;
    kettleAddress: Address;
    confidentialInputsHash: Hash;
};
export type RpcTransactionRequestSuave<TType = SuaveTxType> = TransactionRequestSuave<Hex, Hex> & {
    type: TType;
};
export type TransactionReceiptSuave = TransactionReceipt & SuaveTransactionReceiptOverrides;
export type RpcTransactionReceiptSuave = RpcTransactionReceipt & {};
export type TransactionSerializableEIP2930<TQuantity = bigint, TIndex = number> = TransactionSerializableBase<TQuantity, TIndex> & FeeValues<TQuantity> & {
    accessList?: AccessList;
    chainId: TIndex;
    yParity?: TIndex;
};
export type TransactionSerializableSuave<TQuantity = bigint, TIndex = number, TType = SuaveTxType> = TransactionSerializableEIP2930<TQuantity, TIndex> & ConfidentialComputeRecordOverrides & ConfidentialComputeRequestOverrides & {
    type: TType;
};
/** Required format for a serialized SUAVE transaction.
 *
 * By default, this type can be used to represent any serialized SUAVE transaction.
 *
 * To restrict the type to a specific SUAVE transaction type, use your specific type as
 * the generic TType argument, e.g. `TransactionSerializedSuave<'0x43'>`.
 */
export type TransactionSerializedSuave<TType extends SuaveTxType = SuaveTxType> = `${TType}${string}`;
//# sourceMappingURL=types.d.ts.map