import type { BlockTag } from '../types/block.js';
import type { Hex } from '../types/data.js';
import type { TransactionType } from '../types/transaction.js';
import { BaseError } from './base.js';
export declare function prettyPrint(args: Record<string, bigint | number | string | undefined | false | unknown>): string;
export type FeeConflictErrorType = FeeConflictError & {
    name: 'FeeConflictError';
};
export declare class FeeConflictError extends BaseError {
    constructor();
}
export type InvalidLegacyVErrorType = InvalidLegacyVError & {
    name: 'InvalidLegacyVError';
};
export declare class InvalidLegacyVError extends BaseError {
    constructor({ v }: {
        v: number;
    });
}
export type InvalidSerializableTransactionErrorType = InvalidSerializableTransactionError & {
    name: 'InvalidSerializableTransactionError';
};
export declare class InvalidSerializableTransactionError extends BaseError {
    constructor({ transaction }: {
        transaction: Record<string, unknown>;
    });
}
export type InvalidSerializedTransactionTypeErrorType = InvalidSerializedTransactionTypeError & {
    name: 'InvalidSerializedTransactionTypeError';
};
export declare class InvalidSerializedTransactionTypeError extends BaseError {
    serializedType: Hex;
    constructor({ serializedType }: {
        serializedType: Hex;
    });
}
export type InvalidSerializedTransactionErrorType = InvalidSerializedTransactionError & {
    name: 'InvalidSerializedTransactionError';
};
export declare class InvalidSerializedTransactionError extends BaseError {
    serializedTransaction: Hex;
    type: TransactionType;
    constructor({ attributes, serializedTransaction, type, }: {
        attributes: Record<string, unknown>;
        serializedTransaction: Hex;
        type: TransactionType;
    });
}
export type InvalidStorageKeySizeErrorType = InvalidStorageKeySizeError & {
    name: 'InvalidStorageKeySizeError';
};
export declare class InvalidStorageKeySizeError extends BaseError {
    constructor({ storageKey }: {
        storageKey: Hex;
    });
}
export type TransactionNotFoundErrorType = TransactionNotFoundError & {
    name: 'TransactionNotFoundError';
};
export declare class TransactionNotFoundError extends BaseError {
    constructor({ blockHash, blockNumber, blockTag, hash, index, }: {
        blockHash?: Hex | undefined;
        blockNumber?: bigint | undefined;
        blockTag?: BlockTag | undefined;
        hash?: Hex | undefined;
        index?: number | undefined;
    });
}
export type TransactionReceiptNotFoundErrorType = TransactionReceiptNotFoundError & {
    name: 'TransactionReceiptNotFoundError';
};
export declare class TransactionReceiptNotFoundError extends BaseError {
    constructor({ hash }: {
        hash: Hex;
    });
}
export type WaitForTransactionReceiptTimeoutErrorType = WaitForTransactionReceiptTimeoutError & {
    name: 'WaitForTransactionReceiptTimeoutError';
};
export declare class WaitForTransactionReceiptTimeoutError extends BaseError {
    constructor({ hash }: {
        hash: Hex;
    });
}
//# sourceMappingURL=transaction.d.ts.map