import { aH as BlockHash, b2 as EpochId, b3 as ShardId, C as CryptoHash, b4 as BlockReference, h as RpcTransactionResponse, b5 as PrepareError, b6 as WasmTrap, b7 as AccessKeyPermission, b8 as GlobalContractIdentifier, b9 as MissingTrieValueContext } from '../types.gen-LgOaxt6w.cjs';
import { P as PublicKey } from '../public_key-2MzNRk5k.cjs';

declare class RpcError extends Error {
    readonly name: string;
}
declare class InternalRpcError extends RpcError {
}

declare class HandlerError extends RpcError {
}
declare class AccountDoesNotExistError extends HandlerError {
    readonly accountId: string;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(accountId: string, blockHash: BlockHash, blockHeight: number);
}
declare class AccessKeyDoesNotExistError extends HandlerError {
    readonly publicKey: PublicKey;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(publicKey: PublicKey, blockHash: BlockHash, blockHeight: number);
}
declare class UnknownBlockError extends HandlerError {
    readonly blockReference?: BlockReference | undefined;
    constructor(blockReference?: BlockReference | undefined);
}
declare class GasKeyDoesNotExistError extends HandlerError {
    readonly publicKey: PublicKey;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(publicKey: PublicKey, blockHash: BlockHash, blockHeight: number);
}
declare class GlobalContractCodeDoesNotExistError extends HandlerError {
    readonly identifier: unknown;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(identifier: unknown, blockHash: BlockHash, blockHeight: number);
}
declare class GarbageCollectedBlockError extends HandlerError {
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class InvalidShardIdError extends HandlerError {
    readonly shardId: ShardId;
    constructor(shardId: ShardId);
}
declare class UnavailableShardError extends HandlerError {
    readonly shardId: ShardId;
    constructor(shardId: ShardId);
}
declare class InvalidTransactionError extends HandlerError {
    constructor();
}
declare class UnknownTransactionError extends HandlerError {
    readonly txHash: CryptoHash;
    constructor(txHash: CryptoHash);
}
declare class TransactionTimeoutError extends HandlerError {
    constructor();
}
declare class UnknownEpochError extends HandlerError {
    constructor();
}
declare class EpochOutOfBoundsError extends HandlerError {
    readonly epochId: EpochId;
    constructor(epochId: EpochId);
}
declare class NodeIsSyncingError extends HandlerError {
    constructor();
}
declare class NoNewBlocksError extends HandlerError {
    constructor();
}
declare class UnknownReceiptError extends HandlerError {
    readonly receiptId: CryptoHash;
    constructor(receiptId: CryptoHash);
}
declare class InternalHandlerError extends HandlerError {
}
declare class NotSyncedYetError extends HandlerError {
    constructor();
}
declare class UnknownChunkError extends HandlerError {
    readonly chunkHash: CryptoHash;
    constructor(chunkHash: CryptoHash);
}
declare class DoesNotTrackShardError extends HandlerError {
    constructor();
}
declare class RequestRoutedError extends HandlerError {
    readonly transactionHash: CryptoHash;
    constructor(transactionHash: CryptoHash);
}
declare class ValidatorInfoUnavailableError extends HandlerError {
    constructor();
}
declare class NoSyncedBlocksError extends HandlerError {
    constructor();
}
declare class InvalidAccountError extends HandlerError {
    readonly requestedAccountId: string;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(requestedAccountId: string, blockHash: BlockHash, blockHeight: number);
}
declare class TooLargeContractStateError extends HandlerError {
    readonly contractAccountId: string;
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    constructor(contractAccountId: string, blockHash: BlockHash, blockHeight: number);
}
declare class InconsistentStateError extends HandlerError {
    readonly executionOutcomeShardId: ShardId;
    readonly numberOfShards: number;
    constructor(executionOutcomeShardId: ShardId, numberOfShards: number);
}
declare class NotConfirmedError extends HandlerError {
    readonly transactionOrReceiptId: CryptoHash;
    constructor(transactionOrReceiptId: CryptoHash);
}
declare class UnknownTransactionOrReceiptError extends HandlerError {
    readonly transactionOrReceiptId: CryptoHash;
    constructor(transactionOrReceiptId: CryptoHash);
}

declare class ContractExecutionError extends HandlerError {
    readonly blockHash: BlockHash;
    readonly blockHeight: number;
    /**
     * Complete RPC response when this error was derived from a failed submitted transaction.
     *
     * It is unavailable for read-only (view) calls: they do not submit a transaction or produce receipts.
     */
    transactionResult?: RpcTransactionResponse;
    constructor(message: string, blockHash: BlockHash, blockHeight: number);
}
declare class WasmTrapError extends ContractExecutionError {
    readonly reason: WasmTrap;
    constructor(reason: WasmTrap, blockHash: BlockHash, blockHeight: number);
}
declare class ContractCodeDoesNotExistError extends ContractExecutionError {
    readonly contractId: string;
    constructor(contractId: string, blockHash: BlockHash, blockHeight: number);
}
declare class ContractMethodNotFoundError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class ContractMethodNameEmptyError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class ContractMethodInvalidSignatureError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class PrepareWasmError extends ContractExecutionError {
    readonly reason: PrepareError;
    constructor(reason: PrepareError, blockHash: BlockHash, blockHeight: number);
}
declare class HostBadUtf16Error extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostBadUtf8Error extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostGasExceededError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostGasLimitExceededError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostBalanceExceededError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostEmptyMethodNameError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostGuestPanicError extends ContractExecutionError {
    readonly panicMessage: string;
    constructor(panicMessage: string, blockHash: BlockHash, blockHeight: number);
}
declare class HostIntegerOverflowError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidPromiseIndexError extends ContractExecutionError {
    readonly promiseIndex: number;
    constructor(promiseIndex: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostCannotAppendActionToJointPromiseError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostCannotReturnJointPromiseError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidPromiseResultIndexError extends ContractExecutionError {
    readonly resultIndex: number;
    constructor(resultIndex: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidRegisterIdError extends ContractExecutionError {
    readonly registerId: number;
    constructor(registerId: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostIteratorWasInvalidatedError extends ContractExecutionError {
    readonly iteratorIndex: number;
    constructor(iteratorIndex: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostMemoryAccessViolationError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidReceiptIndexError extends ContractExecutionError {
    readonly receiptIndex: number;
    constructor(receiptIndex: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidIteratorIndexError extends ContractExecutionError {
    readonly iteratorIndex: number;
    constructor(iteratorIndex: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidAccountIdError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidMethodNameError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostInvalidPublicKeyError extends ContractExecutionError {
    constructor(blockHash: BlockHash, blockHeight: number);
}
declare class HostProhibitedInViewError extends ContractExecutionError {
    readonly methodName: string;
    constructor(methodName: string, blockHash: BlockHash, blockHeight: number);
}
declare class HostNumberOfLogsExceededError extends ContractExecutionError {
    readonly limit: number;
    constructor(limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostKeyLengthExceededError extends ContractExecutionError {
    readonly length: number;
    readonly limit: number;
    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostValueLengthExceededError extends ContractExecutionError {
    readonly length: number;
    readonly limit: number;
    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostTotalLogLengthExceededError extends ContractExecutionError {
    readonly length: number;
    readonly limit: number;
    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostNumberPromisesExceededError extends ContractExecutionError {
    readonly limit: number;
    readonly numberOfPromises: number;
    constructor(limit: number, numberOfPromises: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostNumberInputDataDependenciesExceededError extends ContractExecutionError {
    readonly limit: number;
    readonly numberOfInputDataDependencies: number;
    constructor(limit: number, numberOfInputDataDependencies: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostReturnedValueLengthExceededError extends ContractExecutionError {
    readonly length: number;
    readonly limit: number;
    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostSizeExceededError extends ContractExecutionError {
    readonly size: number;
    readonly limit: number;
    constructor(size: number, limit: number, blockHash: BlockHash, blockHeight: number);
}
declare class HostDeprecatedError extends ContractExecutionError {
    readonly methodName: string;
    constructor(methodName: string, blockHash: BlockHash, blockHeight: number);
}
declare class HostECRecoverError extends ContractExecutionError {
    constructor(message: string, blockHash: BlockHash, blockHeight: number);
}
declare class HostAltBn128InvalidInputError extends ContractExecutionError {
    constructor(message: string, blockHash: BlockHash, blockHeight: number);
}
declare class HostEd25519VerifyInvalidInputError extends ContractExecutionError {
    constructor(message: string, blockHash: BlockHash, blockHeight: number);
}

declare class RequestValidationError extends RpcError {
}
declare class RpcMethodNotFoundError extends RequestValidationError {
    readonly methodName: string;
    constructor(methodName: string);
}
declare class RpcRequestParseError extends RequestValidationError {
}

declare class TransactionExecutionError extends RpcError {
    readonly txHash: CryptoHash;
    readonly blockHash: BlockHash;
    /**
     * Complete RPC response when this error was derived from a failed submitted transaction.
     *
     * It is unavailable for read-only (view) calls: they do not submit a transaction or produce receipts.
     */
    transactionResult?: RpcTransactionResponse;
    constructor(message: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ActionExecutionError extends TransactionExecutionError {
    readonly actionIndex: number | null;
    constructor(message: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccountAlreadyExistsActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccountDoesNotExistActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ActorNoPermissionActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly actorId: string;
    constructor(accountId: string, actorId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AddKeyAlreadyExistsActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly publicKey: PublicKey;
    constructor(accountId: string, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeleteKeyDoesNotExistActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly publicKey: PublicKey;
    constructor(accountId: string, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeleteAccountStakingActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class LackBalanceForStateActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly amount: bigint;
    constructor(accountId: string, amount: bigint, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class TriesToUnstakeActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class TriesToStakeActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly balance: bigint;
    readonly locked: bigint;
    readonly stake: bigint;
    constructor(accountId: string, balance: bigint, locked: bigint, stake: bigint, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InsufficientStakeActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly minimumStake: bigint;
    readonly stake: bigint;
    constructor(accountId: string, minimumStake: bigint, stake: bigint, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class OnlyImplicitAccountCreationAllowedActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeleteAccountWithLargeStateActionError extends ActionExecutionError {
    readonly accountId: string;
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionInvalidSignatureActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionExpiredActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionInvalidNonceActionError extends ActionExecutionError {
    readonly akNonce: number;
    readonly delegateNonce: number;
    constructor(akNonce: number, delegateNonce: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionNonceTooLargeActionError extends ActionExecutionError {
    readonly delegateNonce: number;
    readonly upperBound: number;
    constructor(delegateNonce: number, upperBound: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class GasKeyDoesNotExistActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly publicKey: PublicKey;
    constructor(accountId: string, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class GasKeyAlreadyExistsActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly publicKey: PublicKey;
    constructor(accountId: string, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class GlobalContractDoesNotExistActionError extends ActionExecutionError {
    readonly identifier: GlobalContractIdentifier;
    constructor(identifier: GlobalContractIdentifier, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class CreateAccountOnlyByRegistrarActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly predecessorId: string;
    readonly registrarAccountId: string;
    constructor(accountId: string, predecessorId: string, registrarAccountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class CreateAccountNotAllowedActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly predecessorId: string;
    constructor(accountId: string, predecessorId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionSenderDoesNotMatchTxReceiverActionError extends ActionExecutionError {
    readonly receiverId: string;
    readonly senderId: string;
    constructor(receiverId: string, senderId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyNotFoundActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly publicKey: PublicKey;
    constructor(accountId: string, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyReceiverMismatchActionError extends ActionExecutionError {
    readonly akReceiver: string;
    readonly txReceiver: string;
    constructor(akReceiver: string, txReceiver: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyMethodNameMismatchActionError extends ActionExecutionError {
    readonly methodName: string;
    constructor(methodName: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyRequiresFullAccessActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyNotEnoughAllowanceActionError extends ActionExecutionError {
    readonly accountId: string;
    readonly allowance: bigint;
    readonly cost: bigint;
    readonly publicKey: PublicKey;
    constructor(accountId: string, allowance: bigint, cost: bigint, publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AccessKeyDepositWithFunctionCallActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidPredecessorIdReceiptActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidReceiverIdReceiptActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidSignerIdReceiptActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidDataReceiverIdReceiptActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ReturnedValueLengthExceededReceiptActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class NumberInputDataDependenciesExceededReceiptActionError extends ActionExecutionError {
    constructor(limit: number, count: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ReceiptSizeExceededActionError extends ActionExecutionError {
    constructor(limit: number, size: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidRefundToReceiptActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeleteActionMustBeFinalActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class TotalPrepaidGasExceededActionError extends ActionExecutionError {
    constructor(limit: number, total: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class TotalNumberOfActionsExceededActionError extends ActionExecutionError {
    constructor(limit: number, total: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AddKeyMethodNamesNumberOfBytesExceededActionError extends ActionExecutionError {
    constructor(limit: number, totalBytes: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class AddKeyMethodNameLengthExceededActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class IntegerOverflowValidationActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidAccountIdValidationActionError extends ActionExecutionError {
    constructor(accountId: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ContractSizeExceededValidationActionError extends ActionExecutionError {
    constructor(limit: number, size: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class FunctionCallMethodNameLengthExceededActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class FunctionCallArgumentsLengthExceededActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class UnsuitableStakingKeyActionError extends ActionExecutionError {
    constructor(publicKey: PublicKey, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class FunctionCallZeroAttachedGasActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DelegateActionMustBeOnlyOneActionError extends ActionExecutionError {
    constructor(actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class UnsupportedProtocolFeatureActionError extends ActionExecutionError {
    constructor(feature: string, version: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidDeterministicStateInitReceiverActionError extends ActionExecutionError {
    constructor(derived: string, receiver: string, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeterministicStateInitKeyLengthExceededActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class DeterministicStateInitValueLengthExceededActionError extends ActionExecutionError {
    constructor(length: number, limit: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class GasKeyPermissionInvalidActionError extends ActionExecutionError {
    readonly permission: AccessKeyPermission;
    constructor(permission: AccessKeyPermission, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class GasKeyTooManyNoncesRequestedActionError extends ActionExecutionError {
    constructor(limit: number, requested: number, actionIndex: number | null, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidSignerIdError extends TransactionExecutionError {
    readonly signerId: string;
    constructor(signerId: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class SignerDoesNotExistError extends TransactionExecutionError {
    readonly signerId: string;
    constructor(signerId: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidNonceError extends TransactionExecutionError {
    readonly accessKeyNonce: number;
    readonly transactionNonce: number;
    constructor(accessKeyNonce: number, transactionNonce: number, txHash: CryptoHash, blockHash: BlockHash);
}
declare class NonceTooLargeError extends TransactionExecutionError {
    readonly transactionNonce: number;
    readonly upperBound: number;
    constructor(transactionNonce: number, upperBound: number, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidReceiverIdError extends TransactionExecutionError {
    readonly receiverId: string;
    constructor(receiverId: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidSignatureError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class NotEnoughBalanceError extends TransactionExecutionError {
    readonly balance: bigint;
    readonly cost: bigint;
    readonly signerId: string;
    constructor(balance: bigint, cost: bigint, signerId: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class CostOverflowError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidChainError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class TransactionExpiredError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class TransactionSizeExceededError extends TransactionExecutionError {
    readonly limit: number;
    readonly size: number;
    constructor(limit: number, size: number, txHash: CryptoHash, blockHash: BlockHash);
}
declare class InvalidTransactionVersionError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class StorageInternalError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class MissingTrieValueError extends TransactionExecutionError {
    readonly context: MissingTrieValueContext;
    readonly hash: CryptoHash;
    constructor(context: MissingTrieValueContext, hash: CryptoHash, txHash: CryptoHash, blockHash: BlockHash);
}
declare class UnexpectedTrieValueError extends TransactionExecutionError {
    constructor(txHash: CryptoHash, blockHash: BlockHash);
}
declare class StorageInconsistentStateError extends TransactionExecutionError {
    readonly details: string;
    constructor(details: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class FlatStorageBlockNotSupportedError extends TransactionExecutionError {
    readonly details: string;
    constructor(details: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class MemTrieLoadingError extends TransactionExecutionError {
    readonly details: string;
    constructor(details: string, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ShardCongestedError extends TransactionExecutionError {
    readonly congestionLevel: number;
    readonly shardId: number;
    constructor(congestionLevel: number, shardId: number, txHash: CryptoHash, blockHash: BlockHash);
}
declare class ShardStuckError extends TransactionExecutionError {
    readonly missedChunks: number;
    readonly shardId: number;
    constructor(missedChunks: number, shardId: number, txHash: CryptoHash, blockHash: BlockHash);
}

export { AccessKeyDepositWithFunctionCallActionError, AccessKeyDoesNotExistError, AccessKeyMethodNameMismatchActionError, AccessKeyNotEnoughAllowanceActionError, AccessKeyNotFoundActionError, AccessKeyReceiverMismatchActionError, AccessKeyRequiresFullAccessActionError, AccountAlreadyExistsActionError, AccountDoesNotExistActionError, AccountDoesNotExistError, ActionExecutionError, ActorNoPermissionActionError, AddKeyAlreadyExistsActionError, AddKeyMethodNameLengthExceededActionError, AddKeyMethodNamesNumberOfBytesExceededActionError, ContractCodeDoesNotExistError, ContractExecutionError, ContractMethodInvalidSignatureError, ContractMethodNameEmptyError, ContractMethodNotFoundError, ContractSizeExceededValidationActionError, CostOverflowError, CreateAccountNotAllowedActionError, CreateAccountOnlyByRegistrarActionError, DelegateActionExpiredActionError, DelegateActionInvalidNonceActionError, DelegateActionInvalidSignatureActionError, DelegateActionMustBeOnlyOneActionError, DelegateActionNonceTooLargeActionError, DelegateActionSenderDoesNotMatchTxReceiverActionError, DeleteAccountStakingActionError, DeleteAccountWithLargeStateActionError, DeleteActionMustBeFinalActionError, DeleteKeyDoesNotExistActionError, DeterministicStateInitKeyLengthExceededActionError, DeterministicStateInitValueLengthExceededActionError, DoesNotTrackShardError, EpochOutOfBoundsError, FlatStorageBlockNotSupportedError, FunctionCallArgumentsLengthExceededActionError, FunctionCallMethodNameLengthExceededActionError, FunctionCallZeroAttachedGasActionError, GarbageCollectedBlockError, GasKeyAlreadyExistsActionError, GasKeyDoesNotExistActionError, GasKeyDoesNotExistError, GasKeyPermissionInvalidActionError, GasKeyTooManyNoncesRequestedActionError, GlobalContractCodeDoesNotExistError, GlobalContractDoesNotExistActionError, HandlerError, HostAltBn128InvalidInputError, HostBadUtf16Error, HostBadUtf8Error, HostBalanceExceededError, HostCannotAppendActionToJointPromiseError, HostCannotReturnJointPromiseError, HostDeprecatedError, HostECRecoverError, HostEd25519VerifyInvalidInputError, HostEmptyMethodNameError, HostGasExceededError, HostGasLimitExceededError, HostGuestPanicError, HostIntegerOverflowError, HostInvalidAccountIdError, HostInvalidIteratorIndexError, HostInvalidMethodNameError, HostInvalidPromiseIndexError, HostInvalidPromiseResultIndexError, HostInvalidPublicKeyError, HostInvalidReceiptIndexError, HostInvalidRegisterIdError, HostIteratorWasInvalidatedError, HostKeyLengthExceededError, HostMemoryAccessViolationError, HostNumberInputDataDependenciesExceededError, HostNumberOfLogsExceededError, HostNumberPromisesExceededError, HostProhibitedInViewError, HostReturnedValueLengthExceededError, HostSizeExceededError, HostTotalLogLengthExceededError, HostValueLengthExceededError, InconsistentStateError, InsufficientStakeActionError, IntegerOverflowValidationActionError, InternalHandlerError, InternalRpcError, InvalidAccountError, InvalidAccountIdValidationActionError, InvalidChainError, InvalidDataReceiverIdReceiptActionError, InvalidDeterministicStateInitReceiverActionError, InvalidNonceError, InvalidPredecessorIdReceiptActionError, InvalidReceiverIdError, InvalidReceiverIdReceiptActionError, InvalidRefundToReceiptActionError, InvalidShardIdError, InvalidSignatureError, InvalidSignerIdError, InvalidSignerIdReceiptActionError, InvalidTransactionError, InvalidTransactionVersionError, LackBalanceForStateActionError, MemTrieLoadingError, MissingTrieValueError, NoNewBlocksError, NoSyncedBlocksError, NodeIsSyncingError, NonceTooLargeError, NotConfirmedError, NotEnoughBalanceError, NotSyncedYetError, NumberInputDataDependenciesExceededReceiptActionError, OnlyImplicitAccountCreationAllowedActionError, PrepareWasmError, ReceiptSizeExceededActionError, RequestRoutedError, RequestValidationError, ReturnedValueLengthExceededReceiptActionError, RpcError, RpcMethodNotFoundError, RpcRequestParseError, ShardCongestedError, ShardStuckError, SignerDoesNotExistError, StorageInconsistentStateError, StorageInternalError, TooLargeContractStateError, TotalNumberOfActionsExceededActionError, TotalPrepaidGasExceededActionError, TransactionExecutionError, TransactionExpiredError, TransactionSizeExceededError, TransactionTimeoutError, TriesToStakeActionError, TriesToUnstakeActionError, UnavailableShardError, UnexpectedTrieValueError, UnknownBlockError, UnknownChunkError, UnknownEpochError, UnknownReceiptError, UnknownTransactionError, UnknownTransactionOrReceiptError, UnsuitableStakingKeyActionError, UnsupportedProtocolFeatureActionError, ValidatorInfoUnavailableError, WasmTrapError };