/**
 * THIS FILE IS GENERATED - DO NOT MODIFY DIRECTLY
 * Generated by @saka-labsonrpc/jsonrpc-generator with credit to openapi-typescript <3
 *
 * @generated
 */
type AccessKey = {
    /**
     * Format: uint64
     * @description Nonce for this access key, used for tx nonce generation. When access key is created, nonce
     *     is set to `(block_height - 1) * 1e6` to avoid tx hash collision on access key re-creation.
     *     See <https://github.com/near/nearcore/issues/3779> for more details.
     */
    nonce: number;
    /** @description Defines permissions for this access key. */
    permission: AccessKeyPermission;
};
type AccessKeyCreationConfigView = {
    /** @description Base cost of creating a full access access-key. */
    fullAccessCost: Fee;
    /** @description Base cost of creating an access-key restricted to specific functions. */
    functionCallCost: Fee;
    /** @description Cost per byte of method_names of creating a restricted access-key. */
    functionCallCostPerByte: Fee;
};
type AccessKeyInfoView = {
    accessKey: AccessKeyView;
    publicKey: PublicKeyHandle;
};
type AccessKeyList = {
    keys: AccessKeyInfoView[];
    /** @description Pagination cursor. When `Some`, the listing was truncated and the caller
     *     should issue another request with `after_key` set to this handle to fetch
     *     the next page. `None` means this was the last page. */
    lastKey?: PublicKeyHandle | (null);
};
type AccessKeyPermission = {
    FunctionCall: FunctionCallPermission;
} | "FullAccess" | {
    GasKeyFunctionCall: [
        GasKeyInfo,
        FunctionCallPermission
    ];
} | {
    GasKeyFullAccess: GasKeyInfo;
};
type AccessKeyPermissionView = "FullAccess" | {
    FunctionCall: {
        allowance?: NearToken | (null);
        methodNames: string[];
        receiverId: string;
    };
} | {
    GasKeyFunctionCall: {
        allowance?: NearToken | (null);
        balance: NearToken;
        methodNames: string[];
        /** Format: uint16 */
        numNonces: number;
        receiverId: string;
    };
} | {
    GasKeyFullAccess: {
        balance: NearToken;
        /** Format: uint16 */
        numNonces: number;
    };
};
type AccessKeyView = {
    /**
     * Format: uint64
     * @description Current nonce; each transaction signed with this key must use a strictly greater value.
     */
    nonce: number;
    /** @description Access scope: full access, or a function-call permission with an optional allowance and method/receiver limits. */
    permission: AccessKeyPermissionView;
};
type AccountContractView = {
    local: CryptoHash;
} | {
    globalHash: CryptoHash;
} | {
    globalAccountId: AccountId;
};
type AccountCreationConfigView = {
    /**
     * Format: uint8
     * @description The minimum length of the top-level account ID that is allowed to be created by any account.
     */
    minAllowedTopLevelAccountLength?: number;
    /** @description The account ID of the account registrar. This account ID allowed to create top-level
     *     accounts of any valid length. */
    registrarAccountId?: AccountId;
};
type AccountDataView = {
    /** @description Account key of the validator signing this AccountData. */
    accountKey: PublicKey;
    /** @description ID of the node that handles the account key (aka validator key). */
    peerId: PublicKey;
    /** @description Proxy nodes that are directly connected to the validator node
     *     (this list may include the validator node itself).
     *     TIER1 nodes should connect to one of the proxies to sent TIER1
     *     messages to the validator. */
    proxies: Tier1ProxyView[];
    /** @description UTC timestamp of when the AccountData has been signed. */
    timestamp: string;
};
type AccountId = string;
type AccountIdValidityRulesVersion = number;
type AccountInfo = {
    accountId: AccountId;
    amount: NearToken;
    publicKey: PublicKey;
};
type AccountView = {
    /** @description Liquid (non-staked) account balance, in yoctoNEAR. */
    amount: NearToken;
    /** @description Hash of the deployed contract code; the all-`1`s hash when no contract is deployed. */
    codeHash: CryptoHash;
    /** @description Set when the account uses a global contract referenced by the deploying account id. */
    globalContractAccountId?: AccountId | (null);
    /** @description Set when the account uses a global contract referenced by code hash. */
    globalContractHash?: CryptoHash | (null);
    /** @description Staked balance locked for validation, in yoctoNEAR. */
    locked: NearToken;
    /**
     * Format: uint64
     * @description Deprecated and unused. TODO(2271): remove.
     * @default 0
     */
    storagePaidAt: number;
    /**
     * Format: uint64
     * @description Total storage used by the account, in bytes.
     */
    storageUsage: number;
};
type AccountWithPublicKey = {
    accountId: AccountId;
    publicKey: PublicKey;
};
type ActionCreationConfigView = {
    /** @description Base cost of adding a key. */
    addKeyCost?: AccessKeyCreationConfigView;
    /** @description Base cost of creating an account. */
    createAccountCost?: Fee;
    /** @description Base cost for processing a delegate action.
     *
     *     This is on top of the costs for the actions inside the delegate action. */
    delegateCost?: Fee;
    /** @description Base cost of deleting an account. */
    deleteAccountCost?: Fee;
    /** @description Base cost of deleting a key. */
    deleteKeyCost?: Fee;
    /** @description Base cost of deploying a contract. */
    deployContractCost?: Fee;
    /** @description Cost per byte of deploying a contract. */
    deployContractCostPerByte?: Fee;
    /** @description Base cost of calling a function. */
    functionCallCost?: Fee;
    /** @description Cost per byte of method name and arguments of calling a function. */
    functionCallCostPerByte?: Fee;
    /** @description Base cost of staking. */
    stakeCost?: Fee;
    /** @description Base cost of making a transfer. */
    transferCost?: Fee;
};
type ActionError = {
    /**
     * Format: uint64
     * @description Index of the failed action in the transaction.
     *     Action index is not defined if ActionError.kind is `ActionErrorKind::LackBalanceForState`
     */
    index?: number | null;
    /** @description The kind of ActionError happened */
    kind: ActionErrorKind;
};
type ActionErrorKind = {
    AccountAlreadyExists: {
        accountId: AccountId;
    };
} | {
    AccountDoesNotExist: {
        accountId: AccountId;
    };
} | {
    CreateAccountOnlyByRegistrar: {
        accountId: AccountId;
        predecessorId: AccountId;
        registrarAccountId: AccountId;
    };
} | {
    CreateAccountNotAllowed: {
        accountId: AccountId;
        predecessorId: AccountId;
    };
} | {
    ActorNoPermission: {
        accountId: AccountId;
        actorId: AccountId;
    };
} | {
    DeleteKeyDoesNotExist: {
        accountId: AccountId;
        publicKey: PublicKey;
    };
} | {
    AddKeyAlreadyExists: {
        accountId: AccountId;
        publicKey: PublicKey;
    };
} | {
    DeleteAccountStaking: {
        accountId: AccountId;
    };
} | {
    LackBalanceForState: {
        /** @description An account which needs balance */
        accountId: AccountId;
        /** @description Balance required to complete an action. */
        amount: NearToken;
    };
} | {
    TriesToUnstake: {
        accountId: AccountId;
    };
} | {
    TriesToStake: {
        accountId: AccountId;
        balance: NearToken;
        locked: NearToken;
        stake: NearToken;
    };
} | {
    InsufficientStake: {
        accountId: AccountId;
        minimumStake: NearToken;
        stake: NearToken;
    };
} | {
    FunctionCallError: FunctionCallError;
} | {
    NewReceiptValidationError: ReceiptValidationError;
} | {
    OnlyImplicitAccountCreationAllowed: {
        accountId: AccountId;
    };
} | {
    DeleteAccountWithLargeState: {
        accountId: AccountId;
    };
} | "DelegateActionInvalidSignature" | {
    DelegateActionSenderDoesNotMatchTxReceiver: {
        receiverId: AccountId;
        senderId: AccountId;
    };
} | "DelegateActionExpired" | {
    DelegateActionAccessKeyError: InvalidAccessKeyError;
} | {
    DelegateActionInvalidNonce: {
        /** Format: uint64 */
        akNonce: number;
        /** Format: uint64 */
        delegateNonce: number;
    };
} | {
    DelegateActionNonceTooLarge: {
        /** Format: uint64 */
        delegateNonce: number;
        /** Format: uint64 */
        upperBound: number;
    };
} | {
    GlobalContractDoesNotExist: {
        identifier: GlobalContractIdentifier;
    };
} | {
    GasKeyDoesNotExist: {
        accountId: AccountId;
        publicKey: PublicKey;
    };
} | {
    InsufficientGasKeyBalance: {
        accountId: AccountId;
        balance: NearToken;
        publicKey: PublicKey;
        required: NearToken;
    };
} | {
    GasKeyBalanceTooHigh: {
        accountId: AccountId;
        balance: NearToken;
        /** @description Set for DeleteKey (specific key), None for DeleteAccount (aggregate) */
        publicKey?: PublicKey | (null);
    };
} | {
    DelegateActionInvalidNonceIndex: {
        /** Format: uint16 */
        nonceIndex: number;
        /** Format: uint16 */
        numNonces: number;
    };
};
type ActionsValidationError = "DeleteActionMustBeFinal" | {
    TotalPrepaidGasExceeded: {
        limit: NearGas;
        totalPrepaidGas: NearGas;
    };
} | {
    TotalNumberOfActionsExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        totalNumberOfActions: number;
    };
} | {
    AddKeyMethodNamesNumberOfBytesExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        totalNumberOfBytes: number;
    };
} | {
    AddKeyMethodNameLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | "IntegerOverflow" | {
    InvalidAccountId: {
        accountId: string;
    };
} | {
    ContractSizeExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        size: number;
    };
} | {
    FunctionCallMethodNameLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    FunctionCallArgumentsLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    UnsuitableStakingKey: {
        publicKey: PublicKey;
    };
} | "FunctionCallZeroAttachedGas" | "DelegateActionMustBeOnlyOne" | {
    UnsupportedProtocolFeature: {
        protocolFeature: string;
        /** Format: uint32 */
        version: number;
    };
} | {
    InvalidDeterministicStateInitReceiver: {
        derivedId: AccountId;
        receiverId: AccountId;
    };
} | {
    DeterministicStateInitKeyLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    DeterministicStateInitValueLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    GasKeyInvalidNumNonces: {
        /** Format: uint16 */
        limit: number;
        /** Format: uint16 */
        requestedNonces: number;
    };
} | {
    AddGasKeyWithNonZeroBalance: {
        balance: NearToken;
    };
} | "GasKeyFunctionCallAllowanceNotAllowed" | {
    TotalNumberOfDeployActionsExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        numberOfDeployActions: number;
    };
} | "FunctionCallEmptyMethodName";
type ActionView = "CreateAccount" | {
    DeployContract: {
        /** Format: bytes */
        code: string;
    };
} | {
    FunctionCall: {
        args: FunctionArgs;
        deposit: NearToken;
        gas: NearGas;
        methodName: string;
    };
} | {
    Transfer: {
        deposit: NearToken;
    };
} | {
    Stake: {
        publicKey: PublicKey;
        stake: NearToken;
    };
} | {
    AddKey: {
        accessKey: AccessKeyView;
        publicKey: PublicKey;
    };
} | {
    DeleteKey: {
        publicKey: PublicKey;
    };
} | {
    DeleteAccount: {
        beneficiaryId: AccountId;
    };
} | {
    Delegate: {
        delegateAction: DelegateAction;
        signature: Signature;
    };
} | {
    DelegateV2: {
        delegateAction: VersionedDelegateActionPayload;
        signature: Signature;
    };
} | {
    DeployGlobalContract: {
        /** Format: bytes */
        code: string;
    };
} | {
    DeployGlobalContractByAccountId: {
        /** Format: bytes */
        code: string;
    };
} | {
    UseGlobalContract: {
        codeHash: CryptoHash;
    };
} | {
    UseGlobalContractByAccountId: {
        accountId: AccountId;
    };
} | {
    DeterministicStateInit: {
        code: GlobalContractIdentifierView;
        data: {
            [key: string]: string;
        };
        deposit: NearToken;
    };
} | {
    TransferToGasKey: {
        deposit: NearToken;
        publicKey: PublicKey;
    };
} | {
    WithdrawFromGasKey: {
        amount: NearToken;
        publicKey: PublicKey;
    };
};
type AddKeyAction = {
    /** @description An access key with the permission */
    accessKey: AccessKey;
    /** @description A public key which will be associated with an access_key */
    publicKey: PublicKey;
};
type BandwidthRequest = {
    /** @description Bitmap which describes what values of bandwidth are requested. */
    requestedValuesBitmap: BandwidthRequestBitmap;
    /**
     * Format: uint16
     * @description Requesting bandwidth to this shard.
     */
    toShard: number;
};
type BandwidthRequestBitmap = {
    data: number[];
};
type BandwidthRequests = {
    V1: BandwidthRequestsV1;
};
type BandwidthRequestsV1 = {
    requests: BandwidthRequest[];
};
type BlockHeaderInnerLiteView = {
    /** @description The merkle root of all the block hashes */
    blockMerkleRoot: CryptoHash;
    /** @description The epoch to which the block that is the current known head belongs */
    epochId: CryptoHash;
    /** Format: uint64 */
    height: number;
    /** @description The hash of the block producers set for the next epoch */
    nextBpHash: CryptoHash;
    /** @description The epoch that will follow the current epoch */
    nextEpochId: CryptoHash;
    outcomeRoot: CryptoHash;
    prevStateRoot: CryptoHash;
    /**
     * Format: uint64
     * @description Legacy json number. Should not be used.
     */
    timestamp: number;
    timestampNanosec: string;
};
type BlockHeaderView = {
    approvals: (Signature | (null))[];
    blockBodyHash?: CryptoHash | (null);
    blockMerkleRoot: CryptoHash;
    /** Format: uint64 */
    blockOrdinal?: number | null;
    challengesResult: SlashedValidator[];
    challengesRoot: CryptoHash;
    chunkEndorsements?: number[][] | null;
    chunkHeadersRoot: CryptoHash;
    chunkMask: boolean[];
    chunkReceiptsRoot: CryptoHash;
    chunkTxRoot: CryptoHash;
    /** Format: uint64 */
    chunksIncluded: number;
    epochId: CryptoHash;
    epochSyncDataHash?: CryptoHash | (null);
    gasPrice: NearToken;
    hash: CryptoHash;
    /** Format: uint64 */
    height: number;
    lastDsFinalBlock: CryptoHash;
    lastFinalBlock: CryptoHash;
    /** Format: uint32 */
    latestProtocolVersion: number;
    nextBpHash: CryptoHash;
    nextEpochId: CryptoHash;
    outcomeRoot: CryptoHash;
    /** @description The hash of the previous Block */
    prevHash: CryptoHash;
    /** Format: uint64 */
    prevHeight?: number | null;
    prevLastCertifiedBlockEpochId?: EpochId | (null);
    prevStateRoot: CryptoHash;
    randomValue: CryptoHash;
    /**
     * @description TODO(2271): deprecated.
     * @default 0
     */
    rentPaid: NearToken;
    shardSplit?: [
        ShardId,
        AccountId
    ] | null;
    /** @description Signature of the block producer. */
    signature: Signature;
    spiceChunkEndorsementStats?: SpiceChunkEndorsementStats[] | null;
    /**
     * Format: uint64
     * @description Legacy json number. Should not be used.
     */
    timestamp: number;
    timestampNanosec: string;
    totalSupply: NearToken;
    validatorProposals: ValidatorStakeView[];
    /**
     * @description TODO(2271): deprecated.
     * @default 0
     */
    validatorReward: NearToken;
};
type BlockId = number | CryptoHash;
type BlockReference = {
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
};
type BlockStatusView = {
    hash: CryptoHash;
    /** Format: uint64 */
    height: number;
};
type CallResult = {
    logs: string[];
    result: number[];
};
type CatchupStatusView = {
    blocksToCatchup: BlockStatusView[];
    shardSyncStatus: Record<string, unknown>;
    syncBlockHash: CryptoHash;
    /** Format: uint64 */
    syncBlockHeight: number;
};
type ChunkDistributionNetworkConfig = {
    enabled?: boolean;
    uris?: ChunkDistributionUris;
};
type ChunkDistributionUris = {
    /** @description URI for pulling chunks from the stream. */
    get?: string;
    /** @description URI for publishing chunks to the stream. */
    set?: string;
};
type ChunkHash = CryptoHash;
type ChunkHeaderView = {
    balanceBurnt: NearToken;
    bandwidthRequests?: BandwidthRequests | (null);
    chunkHash: CryptoHash;
    congestionInfo?: CongestionInfoView | (null);
    /** Format: uint64 */
    encodedLength: number;
    encodedMerkleRoot: CryptoHash;
    gasLimit: NearGas;
    gasUsed: NearGas;
    /** Format: uint64 */
    heightCreated: number;
    /** Format: uint64 */
    heightIncluded: number;
    outcomeRoot: CryptoHash;
    outgoingReceiptsRoot: CryptoHash;
    prevBlockHash: CryptoHash;
    prevStateRoot: CryptoHash;
    /** @description Proposed trie split for dynamic resharding
     *     `None`: field missing (`ShardChunkHeaderInnerV4` or earlier)
     *     `Some(None)`: field present, but not set (`ChunkHeaderInnerV5` or later)
     *     `Some(Some(split))`: field present and set */
    proposedSplit?: TrieSplit | (null);
    /**
     * @description TODO(2271): deprecated.
     * @default 0
     */
    rentPaid: NearToken;
    shardId: ShardId;
    signature: Signature;
    txRoot: CryptoHash;
    validatorProposals: ValidatorStakeView[];
    /**
     * @description TODO(2271): deprecated.
     * @default 0
     */
    validatorReward: NearToken;
};
type CloudArchivalWriterConfig = {
    /**
     * @description Determines whether block-related data should be written to cloud storage.
     * @default false
     */
    archiveBlockData: boolean;
    /**
     * @description Interval at which the system checks for new blocks or chunks to archive.
     * @default {
     *       "nanos": 0,
     *       "secs": 1
     *     }
     */
    pollingInterval: DurationAsStdSchemaProvider;
    /**
     * Format: uint64
     * @description Cadence of state snapshots, in epochs. Higher values reduce bucket cost at
     *     the expense of potentially longer delta replay during reader bootstrap.
     * @default 10
     */
    snapshotEveryNEpochs: number;
};
type CompilationError = {
    CodeDoesNotExist: {
        accountId: AccountId;
    };
} | {
    PrepareError: PrepareError;
} | {
    WasmerCompileError: {
        msg: string;
    };
};
type CongestionControlConfigView = {
    /** @description How much gas the chosen allowed shard can send to a 100% congested shard.
     *
     *     See [`CongestionControlConfig`] for more details. */
    allowedShardOutgoingGas?: NearGas;
    /** @description How much gas in delayed receipts of a shard is 100% incoming congestion.
     *
     *     See [`CongestionControlConfig`] for more details. */
    maxCongestionIncomingGas?: NearGas;
    /**
     * Format: uint64
     * @description How much memory space of all delayed and buffered receipts in a shard is
     *     considered 100% congested.
     *
     *     See [`CongestionControlConfig`] for more details.
     */
    maxCongestionMemoryConsumption?: number;
    /**
     * Format: uint64
     * @description How many missed chunks in a row in a shard is considered 100% congested.
     */
    maxCongestionMissedChunks?: number;
    /** @description How much gas in outgoing buffered receipts of a shard is 100% congested.
     *
     *     Outgoing congestion contributes to overall congestion, which reduces how
     *     much other shards are allowed to forward to this shard. */
    maxCongestionOutgoingGas?: NearGas;
    /** @description The maximum amount of gas attached to receipts a shard can forward to
     *     another shard per chunk.
     *
     *     See [`CongestionControlConfig`] for more details. */
    maxOutgoingGas?: NearGas;
    /** @description The maximum amount of gas in a chunk spent on converting new transactions to
     *     receipts.
     *
     *     See [`CongestionControlConfig`] for more details. */
    maxTxGas?: NearGas;
    /** @description The minimum gas each shard can send to a shard that is not fully congested.
     *
     *     See [`CongestionControlConfig`] for more details. */
    minOutgoingGas?: NearGas;
    /** @description The minimum amount of gas in a chunk spent on converting new transactions
     *     to receipts, as long as the receiving shard is not congested.
     *
     *     See [`CongestionControlConfig`] for more details. */
    minTxGas?: NearGas;
    /**
     * Format: uint64
     * @description Large size limit for outgoing receipts to a shard, used when it's safe
     *     to send a lot of receipts without making the state witness too large.
     *     It limits the total sum of outgoing receipts, not individual receipts.
     */
    outgoingReceiptsBigSizeLimit?: number;
    /**
     * Format: uint64
     * @description The standard size limit for outgoing receipts aimed at a single shard.
     *     This limit is pretty small to keep the size of source_receipt_proofs under control.
     *     It limits the total sum of outgoing receipts, not individual receipts.
     */
    outgoingReceiptsUsualSizeLimit?: number;
    /**
     * Format: double
     * @description How much congestion a shard can tolerate before it stops all shards from
     *     accepting new transactions with the receiver set to the congested shard.
     */
    rejectTxCongestionThreshold?: number;
};
type CongestionInfoView = {
    /** Format: uint16 */
    allowedShard: number;
    bufferedReceiptsGas: string;
    delayedReceiptsGas: string;
    /** Format: uint64 */
    receiptBytes: number;
};
type ContractCodeView = {
    codeBase64: string;
    hash: CryptoHash;
};
type CostGasUsed = {
    cost: string;
    /** @description Either ACTION_COST or WASM_HOST_COST. */
    costCategory: string;
    gasUsed: string;
};
type CreateAccountAction = Record<string, unknown>;
type CryptoHash = string;
type CurrentEpochValidatorInfo = {
    accountId: AccountId;
    isSlashed: boolean;
    /** Format: uint64 */
    numExpectedBlocks: number;
    /**
     * Format: uint64
     * @default 0
     */
    numExpectedChunks: number;
    /**
     * @description Number of chunks this validator was expected to produce in each shard.
     *     Each entry in the array corresponds to the shard in the `shards_produced` array.
     * @default []
     */
    numExpectedChunksPerShard: number[];
    /**
     * Format: uint64
     * @default 0
     */
    numExpectedEndorsements: number;
    /**
     * @description Number of chunks this validator was expected to validate and endorse in each shard.
     *     Each entry in the array corresponds to the shard in the `shards_endorsed` array.
     * @default []
     */
    numExpectedEndorsementsPerShard: number[];
    /** Format: uint64 */
    numProducedBlocks: number;
    /**
     * Format: uint64
     * @default 0
     */
    numProducedChunks: number;
    /** @default [] */
    numProducedChunksPerShard: number[];
    /**
     * Format: uint64
     * @default 0
     */
    numProducedEndorsements: number;
    /** @default [] */
    numProducedEndorsementsPerShard: number[];
    publicKey: PublicKey;
    /** @description Shards this validator is assigned to as chunk producer in the current epoch. */
    shards: ShardId[];
    /**
     * @description Shards this validator is assigned to as chunk validator in the current epoch.
     * @default []
     */
    shardsEndorsed: ShardId[];
    stake: NearToken;
};
type DataReceiptCreationConfigView = {
    /** @description Base cost of creating a data receipt.
     *     Both `send` and `exec` costs are burned when a new receipt has input dependencies. The gas
     *     is charged for each input dependency. The dependencies are specified when a receipt is
     *     created using `promise_then` and `promise_batch_then`.
     *     NOTE: Any receipt with output dependencies will produce data receipts. Even if it fails.
     *     Even if the last action is not a function call (in case of success it will return empty
     *     value). */
    baseCost?: Fee;
    /** @description Additional cost per byte sent.
     *     Both `send` and `exec` costs are burned when a function call finishes execution and returns
     *     `N` bytes of data to every output dependency. For each output dependency the cost is
     *     `(send(sir) + exec()) * N`. */
    costPerByte?: Fee;
};
type DataReceiverView = {
    dataId: CryptoHash;
    receiverId: AccountId;
};
type DelegateAction = {
    /** @description List of actions to be executed.
     *
     *     With the meta transactions MVP defined in NEP-366, nested
     *     DelegateActions are not allowed. A separate type is used to enforce it. */
    actions: NonDelegateAction[];
    /**
     * Format: uint64
     * @description The maximal height of the block in the blockchain below which the given DelegateAction is valid.
     */
    maxBlockHeight: number;
    /**
     * Format: uint64
     * @description Nonce to ensure that the same delegate action is not sent twice by a
     *     relayer and should match for given account's `public_key`.
     *     After this action is processed it will increment.
     */
    nonce: number;
    /** @description Public key used to sign this delegated action. */
    publicKey: PublicKey;
    /** @description Receiver of the delegated actions. */
    receiverId: AccountId;
    /** @description Signer of the delegated actions */
    senderId: AccountId;
};
type DelegateActionV2 = {
    /** @description List of actions to be executed. */
    actions: NonDelegateAction[];
    /**
     * Format: uint64
     * @description The maximal height of the block in the blockchain below which the given DelegateActionV2 is valid.
     */
    maxBlockHeight: number;
    /** @description Nonce of the signing key, advanced when this action is processed. For
     *     a gas key it also selects which of the parallel nonces to advance. */
    nonce: TransactionNonce;
    /** @description Public key used to sign this delegated action. */
    publicKey: PublicKey;
    /** @description Receiver of the delegated actions. */
    receiverId: AccountId;
    /** @description Signer of the delegated actions */
    senderId: AccountId;
};
type DeleteAccountAction = {
    beneficiaryId: AccountId;
};
type DeleteKeyAction = {
    /** @description A public key associated with the access_key to be deleted. */
    publicKey: PublicKey;
};
type DeployContractAction = {
    /** @description WebAssembly binary */
    code: string;
};
type DeployGlobalContractAction = {
    /** @description WebAssembly binary */
    code: string;
    deployMode: GlobalContractDeployMode;
};
type DepositCostFailureReason = "NotEnoughBalance" | "LackBalanceForState";
type DetailedDebugStatus = {
    /** Format: uint64 */
    blockProductionDelayMillis: number;
    catchupStatus: CatchupStatusView[];
    currentHeadStatus: BlockStatusView;
    currentHeaderHeadStatus: BlockStatusView;
    networkInfo: NetworkInfoView;
    syncStatus: string;
};
type DeterministicAccountStateInit = {
    V1: DeterministicAccountStateInitV1;
};
type DeterministicAccountStateInitV1 = {
    code: GlobalContractIdentifier;
    data: {
        [key: string]: string;
    };
};
type DeterministicStateInitAction = {
    deposit: NearToken;
    stateInit: DeterministicAccountStateInit;
};
type Direction = "Left" | "Right";
type DumpConfig = {
    /** @description Location of a json file with credentials allowing access to the bucket. */
    credentialsFile?: string | null;
    /** @description How often to check if a new epoch has started.
     *     Feel free to set to `None`, defaults are sensible. */
    iterationDelay?: DurationAsStdSchemaProvider | (null);
    /** @description Specifies where to write the obtained state parts. */
    location?: ExternalStorageLocation;
    /** @description Use in case a node that dumps state to the external storage
     *     gets in trouble. */
    restartDumpForShards?: ShardId[] | null;
};
type DurationAsStdSchemaProvider = {
    /** Format: int32 */
    nanos: number;
    /** Format: int64 */
    secs: number;
};
type EpochId = CryptoHash;
type EpochSyncConfig = {
    /**
     * Format: uint64
     * @description Number of epochs behind the network head beyond which the node will use
     *     epoch sync instead of header sync. At the consumption site, this is
     *     multiplied by epoch_length to get the horizon in blocks.
     * @default 2
     */
    epochSyncHorizonNumEpochs: number;
    /** @description Timeout for epoch sync requests. The node will continue retrying indefinitely even
     *     if this timeout is exceeded. */
    timeoutForEpochSync?: DurationAsStdSchemaProvider;
};
type ErrorWrapper_for_GenesisConfigError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: GenesisConfigError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcBlockError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcBlockError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcCallFunctionError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcCallFunctionError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcChunkError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcChunkError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcClientConfigError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcClientConfigError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcGasPriceError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcGasPriceError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcLightClientNextBlockError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcLightClientNextBlockError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcLightClientProofError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcLightClientProofError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcMaintenanceWindowsError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcMaintenanceWindowsError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcNetworkInfoError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcNetworkInfoError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcProtocolConfigError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcProtocolConfigError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcQueryError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcQueryError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcReceiptError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcReceiptError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcReceiptToTxError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcReceiptToTxError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcSplitStorageInfoError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcSplitStorageInfoError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcStateChangesError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcStateChangesError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcStatusError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcStatusError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcTransactionError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcTransactionError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcValidatorError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcValidatorError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcViewAccessKeyError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcViewAccessKeyError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcViewAccessKeyListError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcViewAccessKeyListError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcViewAccountError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcViewAccountError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcViewCodeError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcViewCodeError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ErrorWrapper_for_RpcViewStateError = {
    cause: RpcRequestValidationErrorKind;
    /** @enum {string} */
    name: "REQUEST_VALIDATION_ERROR";
} | {
    cause: RpcViewStateError;
    /** @enum {string} */
    name: "HANDLER_ERROR";
} | {
    cause: InternalError;
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type ExecutionMetadataView = {
    /** @description One entry per action in the receipt (V4+ only): the contract attached
     *     to the receiver account immediately before that action ran. The inner
     *     `Option` is `Some` (a tagged contract object) when the account had a
     *     contract and `None` (rendered as JSON `null`) when it did not (e.g. an
     *     account with no code, or one that did not yet exist). The outer
     *     `Option` is `None` for older metadata versions. */
    contracts?: (AccountContractView | (null))[] | null;
    gasProfile?: CostGasUsed[] | null;
    /** Format: uint32 */
    version: number;
};
type ExecutionOutcomeView = {
    /** @description The id of the account on which the execution happens. For transaction this is signer_id,
     *     for receipt this is receiver_id. */
    executorId: AccountId;
    /** @description The amount of the gas burnt by the given transaction or receipt. */
    gasBurnt: NearGas;
    /** @description Logs from this transaction or receipt. */
    logs: string[];
    /**
     * @description Execution metadata, versioned
     * @default {
     *       "version": 1
     *     }
     */
    metadata: ExecutionMetadataView;
    /** @description Receipt IDs generated by this transaction or receipt. */
    receiptIds: CryptoHash[];
    /** @description Execution status. Contains the result in case of successful execution. */
    status: ExecutionStatusView;
    /** @description The amount of tokens burnt corresponding to the burnt gas amount.
     *     This value doesn't always equal to the `gas_burnt` multiplied by the gas price, because
     *     the prepaid gas price might be lower than the actual gas price and it creates a deficit.
     *     `tokens_burnt` also contains the penalty subtracted from refunds, while
     *     `gas_burnt` only contains the gas that we actually burn for the execution. */
    tokensBurnt: NearToken;
};
type ExecutionOutcomeWithIdView = {
    blockHash: CryptoHash;
    id: CryptoHash;
    outcome: ExecutionOutcomeView;
    proof: MerklePathItem[];
};
type ExecutionStatusView = "Unknown" | {
    Failure: TxExecutionError;
} | {
    SuccessValue: string;
} | {
    SuccessReceiptId: CryptoHash;
};
type ExtCostsConfigView = {
    /** @description Base cost for multiexp */
    altBn128G1MultiexpBase?: NearGas;
    /** @description Per element cost for multiexp */
    altBn128G1MultiexpElement?: NearGas;
    /** @description Base cost for sum */
    altBn128G1SumBase?: NearGas;
    /** @description Per element cost for sum */
    altBn128G1SumElement?: NearGas;
    /** @description Base cost for pairing check */
    altBn128PairingCheckBase?: NearGas;
    /** @description Per element cost for pairing check */
    altBn128PairingCheckElement?: NearGas;
    /** @description Base cost for calling a host function. */
    base?: NearGas;
    bls12381G1MultiexpBase?: NearGas;
    bls12381G1MultiexpElement?: NearGas;
    bls12381G2MultiexpBase?: NearGas;
    bls12381G2MultiexpElement?: NearGas;
    bls12381MapFpToG1Base?: NearGas;
    bls12381MapFpToG1Element?: NearGas;
    bls12381MapFp2ToG2Base?: NearGas;
    bls12381MapFp2ToG2Element?: NearGas;
    bls12381P1DecompressBase?: NearGas;
    bls12381P1DecompressElement?: NearGas;
    bls12381P1SumBase?: NearGas;
    bls12381P1SumElement?: NearGas;
    bls12381P2DecompressBase?: NearGas;
    bls12381P2DecompressElement?: NearGas;
    bls12381P2SumBase?: NearGas;
    bls12381P2SumElement?: NearGas;
    bls12381PairingBase?: NearGas;
    bls12381PairingElement?: NearGas;
    contractCompileBase?: NearGas;
    contractCompileBytes?: NearGas;
    /** @description Base cost of loading a pre-compiled contract */
    contractLoadingBase?: NearGas;
    /** @description Cost per byte of loading a pre-compiled contract */
    contractLoadingBytes?: NearGas;
    /** @description Cost of calling ecrecover */
    ecrecoverBase?: NearGas;
    /** @description Cost of getting ed25519 base */
    ed25519VerifyBase?: NearGas;
    /** @description Cost of getting ed25519 per byte */
    ed25519VerifyByte?: NearGas;
    /** @description Cost of getting sha256 base */
    keccak256Base?: NearGas;
    /** @description Cost of getting sha256 per byte */
    keccak256Byte?: NearGas;
    /** @description Cost of getting sha256 base */
    keccak512Base?: NearGas;
    /** @description Cost of getting sha256 per byte */
    keccak512Byte?: NearGas;
    /** @description Cost for calling logging. */
    logBase?: NearGas;
    /** @description Cost for logging per byte */
    logByte?: NearGas;
    /** @description Cost of ML-DSA-65 signature verification base */
    mlDsaVerifyBase?: NearGas;
    /** @description Cost of ML-DSA-65 signature verification per byte */
    mlDsaVerifyByte?: NearGas;
    /** @description Cost of P-256 ECDSA signature verification base */
    p256VerifyBase?: NearGas;
    /** @description Cost of P-256 ECDSA signature verification per byte */
    p256VerifyByte?: NearGas;
    /** @description Cost for calling `promise_and` */
    promiseAndBase?: NearGas;
    /** @description Cost for calling `promise_and` for each promise */
    promiseAndPerPromise?: NearGas;
    /** @description Cost for calling `promise_return` */
    promiseReturn?: NearGas;
    /** @description Cost for reading trie node from memory */
    readCachedTrieNode?: NearGas;
    /** @description Base cost for guest memory read */
    readMemoryBase?: NearGas;
    /** @description Cost for guest memory read */
    readMemoryByte?: NearGas;
    /** @description Base cost for reading from register */
    readRegisterBase?: NearGas;
    /** @description Cost for reading byte from register */
    readRegisterByte?: NearGas;
    /** @description Cost of getting ripemd160 base */
    ripemd160Base?: NearGas;
    /** @description Cost of getting ripemd160 per message block */
    ripemd160Block?: NearGas;
    /** @description Cost of getting sha3-256 base */
    sha3256Base?: NearGas;
    /** @description Cost of getting sha3-256 per byte */
    sha3256Byte?: NearGas;
    /** @description Cost of getting sha3-384 base */
    sha3384Base?: NearGas;
    /** @description Cost of getting sha3-384 per byte */
    sha3384Byte?: NearGas;
    /** @description Cost of getting sha3-512 base */
    sha3512Base?: NearGas;
    /** @description Cost of getting sha3-512 per byte */
    sha3512Byte?: NearGas;
    /** @description Cost of getting sha256 base */
    sha256Base?: NearGas;
    /** @description Cost of getting sha256 per byte */
    sha256Byte?: NearGas;
    /** @description Storage trie check for key existence cost base */
    storageHasKeyBase?: NearGas;
    /** @description Storage trie check for key existence per key byte */
    storageHasKeyByte?: NearGas;
    /** @description Create trie range iterator cost per byte of from key. */
    storageIterCreateFromByte?: NearGas;
    /** @description Create trie prefix iterator cost base */
    storageIterCreatePrefixBase?: NearGas;
    /** @description Create trie prefix iterator cost per byte. */
    storageIterCreatePrefixByte?: NearGas;
    /** @description Create trie range iterator cost base */
    storageIterCreateRangeBase?: NearGas;
    /** @description Create trie range iterator cost per byte of to key. */
    storageIterCreateToByte?: NearGas;
    /** @description Trie iterator per key base cost */
    storageIterNextBase?: NearGas;
    /** @description Trie iterator next key byte cost */
    storageIterNextKeyByte?: NearGas;
    /** @description Trie iterator next key byte cost */
    storageIterNextValueByte?: NearGas;
    /** @description Storage trie read key overhead base cost, when doing large reads */
    storageLargeReadOverheadBase?: NearGas;
    /** @description Storage trie read key overhead  per-byte cost, when doing large reads */
    storageLargeReadOverheadByte?: NearGas;
    /** @description Storage trie read key base cost */
    storageReadBase?: NearGas;
    /** @description Storage trie read key per byte cost */
    storageReadKeyByte?: NearGas;
    /** @description Storage trie read value cost per byte cost */
    storageReadValueByte?: NearGas;
    /** @description Remove key from trie base cost */
    storageRemoveBase?: NearGas;
    /** @description Remove key from trie per byte cost */
    storageRemoveKeyByte?: NearGas;
    /** @description Remove key from trie ret value byte cost */
    storageRemoveRetValueByte?: NearGas;
    /** @description Storage trie write key base cost */
    storageWriteBase?: NearGas;
    /** @description Storage trie write cost per byte of evicted value. */
    storageWriteEvictedByte?: NearGas;
    /** @description Storage trie write key per byte cost */
    storageWriteKeyByte?: NearGas;
    /** @description Storage trie write value per byte cost */
    storageWriteValueByte?: NearGas;
    /** @description Cost per reading trie node from DB */
    touchingTrieNode?: NearGas;
    /** @description Base cost of decoding utf8. It's used for `log_utf8` and `panic_utf8`. */
    utf8DecodingBase?: NearGas;
    /** @description Cost per byte of decoding utf8. It's used for `log_utf8` and `panic_utf8`. */
    utf8DecodingByte?: NearGas;
    /** @description Base cost of decoding utf16. It's used for `log_utf16`. */
    utf16DecodingBase?: NearGas;
    /** @description Cost per byte of decoding utf16. It's used for `log_utf16`. */
    utf16DecodingByte?: NearGas;
    /** @description Cost of calling `validator_stake`. */
    validatorStakeBase?: NearGas;
    /** @description Cost of calling `validator_total_stake`. */
    validatorTotalStakeBase?: NearGas;
    /** @description Base cost for guest memory write */
    writeMemoryBase?: NearGas;
    /** @description Cost for guest memory write per byte */
    writeMemoryByte?: NearGas;
    /** @description Base cost for writing into register */
    writeRegisterBase?: NearGas;
    /** @description Cost for writing byte into register */
    writeRegisterByte?: NearGas;
    /** @description Base cost for creating a yield promise. */
    yieldCreateBase?: NearGas;
    /** @description Per byte cost of arguments and method name. */
    yieldCreateByte?: NearGas;
    /** @description Base cost for creating a yield promise with a user-provided yield ID
     *     (covers the additional trie writes for the yield_id<->data_id mapping). */
    yieldCreateWithIdBase?: NearGas;
    /** @description Base cost for resuming a yield receipt. */
    yieldResumeBase?: NearGas;
    /** @description Per byte cost of resume payload. */
    yieldResumeByte?: NearGas;
};
type ExternalStorageLocation = {
    S3: {
        /** @description Location on S3. */
        bucket: string;
        /** @description Data may only be available in certain locations. */
        region: string;
    };
} | {
    Filesystem: {
        rootDir: string;
    };
} | {
    GCS: {
        bucket: string;
    };
};
type Fee = {
    /** @description Fee for executing the object. */
    execution: NearGas;
    /** @description Fee for sending an object potentially across the shards. */
    sendNotSir: NearGas;
    /** @description Fee for sending an object from the sender to itself, guaranteeing that it does not leave
     *     the shard. */
    sendSir: NearGas;
};
type FinalExecutionOutcomeView = {
    /** @description The execution outcome of receipts. */
    receiptsOutcome: ExecutionOutcomeWithIdView[];
    /** @description Execution status defined by chain.rs:get_final_transaction_result
     *     FinalExecutionStatus::NotStarted - the tx is not converted to the receipt yet
     *     FinalExecutionStatus::Started - we have at least 1 receipt, but the first leaf receipt_id (using dfs) hasn't finished the execution
     *     FinalExecutionStatus::Failure - the result of the first leaf receipt_id
     *     FinalExecutionStatus::SuccessValue - the result of the first leaf receipt_id */
    status: FinalExecutionStatus;
    /** @description Signed Transaction */
    transaction: SignedTransactionView;
    /** @description The execution outcome of the signed transaction. */
    transactionOutcome: ExecutionOutcomeWithIdView;
};
type FinalExecutionOutcomeWithReceiptView = {
    /** @description Receipts generated from the transaction */
    receipts: ReceiptView[];
    /** @description The execution outcome of receipts. */
    receiptsOutcome: ExecutionOutcomeWithIdView[];
    /** @description Execution status defined by chain.rs:get_final_transaction_result
     *     FinalExecutionStatus::NotStarted - the tx is not converted to the receipt yet
     *     FinalExecutionStatus::Started - we have at least 1 receipt, but the first leaf receipt_id (using dfs) hasn't finished the execution
     *     FinalExecutionStatus::Failure - the result of the first leaf receipt_id
     *     FinalExecutionStatus::SuccessValue - the result of the first leaf receipt_id */
    status: FinalExecutionStatus;
    /** @description Signed Transaction */
    transaction: SignedTransactionView;
    /** @description The execution outcome of the signed transaction. */
    transactionOutcome: ExecutionOutcomeWithIdView;
};
type FinalExecutionStatus = "NotStarted" | "Started" | {
    Failure: TxExecutionError;
} | {
    SuccessValue: string;
};
type Finality = "optimistic" | "near-final" | "final";
type FunctionArgs = string;
type FunctionCallAction = {
    args: string;
    deposit: NearToken;
    gas: NearGas;
    methodName: string;
};
type FunctionCallError = ("WasmUnknownError" | "_EVMError") | {
    CompilationError: CompilationError;
} | {
    LinkError: {
        msg: string;
    };
} | {
    MethodResolveError: MethodResolveError;
} | {
    WasmTrap: WasmTrap;
} | {
    HostError: HostError;
} | {
    ExecutionError: string;
};
type FunctionCallPermission = {
    /** @description Allowance is a balance limit to use by this access key to pay for function call gas and
     *     transaction fees. When this access key is used, both account balance and the allowance is
     *     decreased by the same value.
     *     `None` means unlimited allowance.
     *     NOTE: To change or increase the allowance, the old access key needs to be deleted and a new
     *     access key should be created. */
    allowance?: NearToken | (null);
    /** @description A list of method names that can be used. The access key only allows transactions with the
     *     function call of one of the given method names.
     *     Empty list means any method name can be used. */
    methodNames: string[];
    /** @description The access key only allows transactions with the given receiver's account id. */
    receiverId: string;
};
type GasKeyInfo = {
    balance: NearToken;
    /** Format: uint16 */
    numNonces: number;
};
type GasKeyNoncesView = {
    nonces: number[];
};
type GCConfig = {
    /**
     * Format: uint64
     * @description Maximum number of blocks to garbage collect at every garbage collection
     *     call.
     * @default 2
     */
    gcBlocksLimit: number;
    /**
     * Format: uint64
     * @description Maximum number of height to go through at each garbage collection step
     *     when cleaning forks during garbage collection.
     * @default 100
     */
    gcForkCleanStep: number;
    /**
     * Format: uint64
     * @description Number of epochs for which we keep store data.
     * @default 5
     */
    gcNumEpochsToKeep: number;
    /**
     * @description How often gc should be run
     * @default {
     *       "nanos": 500000000,
     *       "secs": 0
     *     }
     */
    gcStepPeriod: DurationAsStdSchemaProvider;
};
type GenesisConfig = {
    /**
     * Format: uint8
     * @description Threshold for kicking out block producers, between 0 and 100.
     */
    blockProducerKickoutThreshold: number;
    /** @description ID of the blockchain. This must be unique for every blockchain.
     *     If your testnet blockchains do not have unique chain IDs, you will have a bad time. */
    chainId: string;
    /**
     * Format: uint64
     * @description Limits the number of shard changes in chunk producer assignments,
     *     if algorithm is able to choose assignment with better balance of
     *     number of chunk producers for shards.
     * @default 5
     */
    chunkProducerAssignmentChangesLimit: number;
    /**
     * Format: uint8
     * @description Threshold for kicking out chunk producers, between 0 and 100.
     */
    chunkProducerKickoutThreshold: number;
    /**
     * Format: uint8
     * @description Threshold for kicking out nodes which are only chunk validators, between 0 and 100.
     * @default 80
     */
    chunkValidatorOnlyKickoutThreshold: number;
    /** @description Enable dynamic re-sharding. */
    dynamicResharding: boolean;
    /**
     * Format: uint64
     * @description Epoch length counted in block heights.
     */
    epochLength: number;
    /** @description Fishermen stake threshold. */
    fishermenThreshold: NearToken;
    /** @description Initial gas limit. */
    gasLimit: NearGas;
    /** @description Gas price adjustment rate */
    gasPriceAdjustmentRate: number[];
    /**
     * Format: uint64
     * @description Height of genesis block.
     */
    genesisHeight: number;
    /**
     * Format: date-time
     * @description Official time of blockchain start.
     */
    genesisTime: string;
    maxGasPrice: NearToken;
    /** @description Maximum inflation on the total supply every epoch. */
    maxInflationRate: number[];
    /**
     * Format: uint8
     * @description Max stake percentage of the validators we will kick out.
     * @default 100
     */
    maxKickoutStakePerc: number;
    /** @description Minimum gas price. It is also the initial gas price. */
    minGasPrice: NearToken;
    /**
     * Format: uint64
     * @description The minimum stake required for staking is last seat price divided by this number.
     * @default 10
     */
    minimumStakeDivisor: number;
    /**
     * @description The lowest ratio s/s_total any block producer can have.
     *     See <https://github.com/near/NEPs/pull/167> for details
     * @default [
     *       1,
     *       6250
     *     ]
     */
    minimumStakeRatio: number[];
    /**
     * Format: uint64
     * @description The minimum number of validators each shard must have
     * @default 1
     */
    minimumValidatorsPerShard: number;
    /**
     * Format: uint64
     * @description Number of block producer seats at genesis.
     */
    numBlockProducerSeats: number;
    /**
     * Format: uint64
     * @description Expected number of blocks per year
     */
    numBlocksPerYear: number;
    /**
     * Format: uint64
     * @description Number of chunk producers.
     *     Don't mess it up with chunk-only producers feature which is deprecated.
     * @default 100
     */
    numChunkProducerSeats: number;
    /**
     * Format: uint64
     * @default 300
     */
    numChunkValidatorSeats: number;
    /**
     * @description Online maximum threshold above which validator gets full reward.
     * @default [
     *       99,
     *       100
     *     ]
     */
    onlineMaxThreshold: number[];
    /**
     * @description Online minimum threshold below which validator doesn't receive reward.
     * @default [
     *       9,
     *       10
     *     ]
     */
    onlineMinThreshold: number[];
    /** @description Protocol treasury rate */
    protocolRewardRate: number[];
    /** @description Protocol treasury account */
    protocolTreasuryAccount: AccountId;
    /**
     * @description Threshold of stake that needs to indicate that they ready for upgrade.
     * @default [
     *       4,
     *       5
     *     ]
     */
    protocolUpgradeStakeThreshold: number[];
    /**
     * Format: uint32
     * @description Protocol version that this genesis works with.
     */
    protocolVersion: number;
    /**
     * @description Layout information regarding how to split accounts to shards
     * @default {
     *       "V2": {
     *         "boundary_accounts": [],
     *         "id_to_index_map": {
     *           "0": 0
     *         },
     *         "index_to_id_map": {
     *           "0": 0
     *         },
     *         "shard_ids": [
     *           0
     *         ],
     *         "version": 0
     *       }
     *     }
     */
    shardLayout: ShardLayout;
    /**
     * @description If true, shuffle the chunk producers across shards. In other words, if
     *     the shard assignments were `[S_0, S_1, S_2, S_3]` where `S_i` represents
     *     the set of chunk producers for shard `i`, if this flag were true, the
     *     shard assignments might become, for example, `[S_2, S_0, S_3, S_1]`.
     * @default false
     */
    shuffleShardAssignmentForChunkProducers: boolean;
    /**
     * Format: uint64
     * @description Number of target chunk validator mandates for each shard.
     * @default 68
     */
    targetValidatorMandatesPerShard: number;
    /** @description Total supply of tokens at genesis. */
    totalSupply: NearToken;
    /**
     * Format: uint64
     * @description Number of blocks for which a given transaction is valid
     */
    transactionValidityPeriod: number;
    /**
     * @description This is only for test purposes. We hard code some configs for mainnet and testnet
     *     in AllEpochConfig, and we want to have a way to test that code path. This flag is for that.
     *     If set to true, the node will use the same config override path as mainnet and testnet.
     * @default false
     */
    useProductionConfig: boolean;
    /** @description List of initial validators. */
    validators: AccountInfo[];
};
type GenesisConfigError = null;
type GenesisConfigRequest = null;
type GlobalContractDeployMode = "CodeHash" | "AccountId";
type GlobalContractIdentifier = {
    hash: CryptoHash;
} | {
    accountId: AccountId;
};
type GlobalContractIdentifierView = {
    hash: CryptoHash;
} | {
    accountId: AccountId;
};
type HostError = "BadUTF16" | "BadUTF8" | "GasExceeded" | "GasLimitExceeded" | "BalanceExceeded" | "EmptyMethodName" | {
    GuestPanic: {
        panicMsg: string;
    };
} | "IntegerOverflow" | {
    InvalidPromiseIndex: {
        /** Format: uint64 */
        promiseIdx: number;
    };
} | "CannotAppendActionToJointPromise" | "CannotReturnJointPromise" | {
    InvalidPromiseResultIndex: {
        /** Format: uint64 */
        resultIdx: number;
    };
} | {
    InvalidRegisterId: {
        /** Format: uint64 */
        registerId: number;
    };
} | {
    IteratorWasInvalidated: {
        /** Format: uint64 */
        iteratorIndex: number;
    };
} | "MemoryAccessViolation" | {
    InvalidReceiptIndex: {
        /** Format: uint64 */
        receiptIndex: number;
    };
} | {
    InvalidIteratorIndex: {
        /** Format: uint64 */
        iteratorIndex: number;
    };
} | "InvalidAccountId" | "InvalidMethodName" | "InvalidPublicKey" | {
    ProhibitedInView: {
        methodName: string;
    };
} | {
    NumberOfLogsExceeded: {
        /** Format: uint64 */
        limit: number;
    };
} | {
    KeyLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    ValueLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    TotalLogLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    NumberPromisesExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        numberOfPromises: number;
    };
} | {
    NumberInputDataDependenciesExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        numberOfInputDataDependencies: number;
    };
} | {
    ReturnedValueLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    ContractSizeExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        size: number;
    };
} | {
    Deprecated: {
        methodName: string;
    };
} | {
    ECRecoverError: {
        msg: string;
    };
} | {
    AltBn128InvalidInput: {
        msg: string;
    };
} | {
    Ed25519VerifyInvalidInput: {
        msg: string;
    };
} | {
    P256VerifyInvalidInput: {
        msg: string;
    };
} | {
    MlDsaVerifyInvalidInput: {
        msg: string;
    };
};
type InternalError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type InvalidAccessKeyError = {
    AccessKeyNotFound: {
        accountId: AccountId;
        publicKey: PublicKey;
    };
} | {
    ReceiverMismatch: {
        akReceiver: string;
        txReceiver: AccountId;
    };
} | {
    MethodNameMismatch: {
        methodName: string;
    };
} | "RequiresFullAccess" | {
    NotEnoughAllowance: {
        accountId: AccountId;
        allowance: NearToken;
        cost: NearToken;
        publicKey: PublicKey;
    };
} | "DepositWithFunctionCall" | "DelegateActionRequiresNonGasKey" | "DelegateActionRequiresGasKey";
type InvalidTxError = {
    InvalidAccessKeyError: InvalidAccessKeyError;
} | {
    InvalidSignerId: {
        signerId: string;
    };
} | {
    SignerDoesNotExist: {
        signerId: AccountId;
    };
} | {
    InvalidNonce: {
        /** Format: uint64 */
        akNonce: number;
        /** Format: uint64 */
        txNonce: number;
    };
} | {
    NonceTooLarge: {
        /** Format: uint64 */
        txNonce: number;
        /** Format: uint64 */
        upperBound: number;
    };
} | {
    InvalidReceiverId: {
        receiverId: string;
    };
} | "InvalidSignature" | {
    NotEnoughBalance: {
        balance: NearToken;
        cost: NearToken;
        signerId: AccountId;
    };
} | {
    LackBalanceForState: {
        /** @description Required balance to cover the state. */
        amount: NearToken;
        /** @description An account which doesn't have enough balance to cover storage. */
        signerId: AccountId;
    };
} | "CostOverflow" | "InvalidChain" | "Expired" | {
    ActionsValidation: ActionsValidationError;
} | {
    TransactionSizeExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        size: number;
    };
} | "InvalidTransactionVersion" | {
    StorageError: StorageError;
} | {
    ShardCongested: {
        /**
         * Format: double
         * @description A value between 0 (no congestion) and 1 (max congestion).
         */
        congestionLevel: number;
        /**
         * Format: uint32
         * @description The congested shard.
         */
        shardId: number;
    };
} | {
    ShardStuck: {
        /**
         * Format: uint64
         * @description The number of blocks since the last included chunk of the shard.
         */
        missedChunks: number;
        /**
         * Format: uint32
         * @description The shard that fails making progress.
         */
        shardId: number;
    };
} | {
    InvalidNonceIndex: {
        /**
         * Format: uint16
         * @description Number of nonces supported by the key. 0 means no nonce_index allowed (regular key).
         */
        numNonces: number;
        /**
         * Format: uint16
         * @description The nonce_index from the transaction (None if missing).
         */
        txNonceIndex?: number | null;
    };
} | {
    NotEnoughGasKeyBalance: {
        balance: NearToken;
        cost: NearToken;
        signerId: AccountId;
    };
} | {
    NotEnoughBalanceForDeposit: {
        balance: NearToken;
        cost: NearToken;
        reason: DepositCostFailureReason;
        signerId: AccountId;
    };
};
type KnownProducerView = {
    accountId: AccountId;
    nextHops?: PublicKey[] | null;
    peerId: PublicKey;
};
type LightClientBlockLiteView = {
    innerLite: BlockHeaderInnerLiteView;
    innerRestHash: CryptoHash;
    prevBlockHash: CryptoHash;
};
type LimitConfig = {
    /**
     * @description Whether to enforce account_id well-formed-ness where it wasn't enforced
     *     historically.
     * @default 0
     */
    accountIdValidityRulesVersion: AccountIdValidityRulesVersion;
    /**
     * Format: uint32
     * @description The initial number of memory pages.
     *     NOTE: It's not a limiter itself, but it's a value we use for initial_memory_pages.
     */
    initialMemoryPages?: number;
    /**
     * Format: uint64
     * @description Max number of actions per receipt.
     */
    maxActionsPerReceipt?: number;
    /**
     * Format: uint64
     * @description Max length of arguments in a function call action.
     */
    maxArgumentsLength?: number;
    /**
     * Format: uint64
     * @description If present, stores max total number of basic blocks across all functions in a contract.
     *     This caps total compilation time for a contract.
     */
    maxBlocksPerContract?: number | null;
    /**
     * Format: uint64
     * @description If present, stores max number of basic blocks (block/loop/if) in a single function.
     *     This caps per-function compilation time in Cranelift.
     */
    maxBlocksPerFunction?: number | null;
    /**
     * Format: uint64
     * @description Max contract size
     */
    maxContractSize?: number;
    /**
     * Format: uint64
     * @description Max number of `DeployContract` and `DeployGlobalContract` actions
     *     combined within a single receipt.
     */
    maxDeployActionsPerReceipt?: number;
    /**
     * Format: uint
     * @description If present, stores max number of elements in a single contract's table
     */
    maxElementsPerContractTable?: number | null;
    /**
     * Format: uint64
     * @description If present, stores max byte size of a single function body in a contract
     */
    maxFunctionBodySize?: number | null;
    /**
     * Format: uint64
     * @description If present, stores max number of functions in one contract
     */
    maxFunctionsNumberPerContract?: number | null;
    /** @description Max amount of gas that can be used, excluding gas attached to promises. */
    maxGasBurnt?: NearGas;
    /**
     * Format: uint64
     * @description If present, stores max number of globals (entries in the wasm global
     *     section) a contract may declare.
     */
    maxGlobalsPerContract?: number | null;
    /**
     * Format: uint64
     * @description If present, stores max byte size of the wasm code after gas instrumentation.
     *     This prevents Cranelift's 24-bit SSA counter from overflowing on
     *     pathologically large contracts.
     */
    maxInstrumentedCodeSize?: number | null;
    /**
     * Format: uint64
     * @description Max length of any method name (without terminating character).
     */
    maxLengthMethodName?: number;
    /**
     * Format: uint64
     * @description Max length of returned data
     */
    maxLengthReturnedData?: number;
    /**
     * Format: uint64
     * @description Max storage key size
     */
    maxLengthStorageKey?: number;
    /**
     * Format: uint64
     * @description Max storage value size
     */
    maxLengthStorageValue?: number;
    /**
     * Format: uint64
     * @description If present, stores max number of locals declared globally in one contract
     */
    maxLocalsPerContract?: number | null;
    /**
     * Format: uint32
     * @description What is the maximal memory pages amount is allowed to have for a contract.
     */
    maxMemoryPages?: number;
    /**
     * Format: uint64
     * @description Max total length of all method names (including terminating character) for a function call
     *     permission access key.
     */
    maxNumberBytesMethodNames?: number;
    /**
     * Format: uint64
     * @description Max number of input data dependencies
     */
    maxNumberInputDataDependencies?: number;
    /**
     * Format: uint64
     * @description Maximum number of log entries.
     */
    maxNumberLogs?: number;
    /**
     * Format: uint64
     * @description Maximum number of registers that can be used simultaneously.
     *
     *     Note that due to an implementation quirk [read: a bug] in VMLogic, if we
     *     have this number of registers, no subsequent writes to the registers
     *     will succeed even if they replace an existing register.
     */
    maxNumberRegisters?: number;
    /**
     * Format: uint64
     * @description If present, stores the max operand stack size (in bytes) at any point
     *     during the execution of a single function. Per-function: not summed
     *     across recursion. Computed by `finite_wasm::max_stack`.
     */
    maxOperandStackBytesPerFunction?: number | null;
    /** Format: uint64 */
    maxParamsPerContract?: number | null;
    /** Format: uint64 */
    maxParamsPerFunction?: number | null;
    /**
     * Format: uint64
     * @description Max number of promises that a function call can create
     */
    maxPromisesPerFunctionCallAction?: number;
    /**
     * Format: uint64
     * @description Max receipt size
     */
    maxReceiptSize?: number;
    /**
     * Format: uint64
     * @description Maximum number of bytes that can be stored in a single register.
     */
    maxRegisterSize?: number;
    /**
     * Format: uint32
     * @description How tall the stack is allowed to grow?
     *
     *     See <https://wiki.parity.io/WebAssembly-StackHeight> to find out how the stack frame cost
     *     is calculated.
     */
    maxStackHeight?: number;
    /**
     * Format: uint32
     * @description If present, stores max number of tables declared globally in one contract
     */
    maxTablesPerContract?: number | null;
    /**
     * Format: uint64
     * @description Maximum total length in bytes of all log messages.
     */
    maxTotalLogLength?: number;
    /** @description Max total prepaid gas for all function call actions per receipt. */
    maxTotalPrepaidGas?: NearGas;
    /**
     * Format: uint64
     * @description Max transaction size
     */
    maxTransactionSize?: number;
    /**
     * Format: uint64
     * @description If present, stores max number of entries in the wasm type section that
     *     a contract may declare.
     */
    maxTypesPerContract?: number | null;
    /**
     * Format: uint64
     * @description Maximum number of bytes for payload passed over a yield resume.
     */
    maxYieldPayloadSize?: number;
    /**
     * Format: uint
     * @description Hard limit on the size of storage proof generated while executing a single receipt.
     */
    perReceiptStorageProofSizeLimit?: number;
    /**
     * Format: uint64
     * @description Limit of memory used by registers.
     */
    registersMemoryLimit?: number;
    /**
     * Format: uint64
     * @description Number of blocks after which a yielded promise times out.
     */
    yieldTimeoutLengthInBlocks?: number;
};
type LogSummaryStyle = "plain" | "colored";
type MerklePathItem = {
    direction: Direction;
    hash: CryptoHash;
};
type MethodResolveError = "MethodEmptyName" | "MethodNotFound" | "MethodInvalidSignature";
type MissingTrieValue = {
    context: MissingTrieValueContext;
    hash: CryptoHash;
};
type MissingTrieValueContext = "TrieIterator" | "TriePrefetchingStorage" | "TrieMemoryPartialStorage" | "TrieStorage";
type MutableConfigValue = string;
type NearGas = number;
type NearToken = string;
type NetworkInfoView = {
    connectedPeers: PeerInfoView[];
    knownProducers: KnownProducerView[];
    /** Format: uint */
    numConnectedPeers: number;
    /** Format: uint32 */
    peerMaxCount: number;
    tier1AccountsData: AccountDataView[];
    tier1AccountsKeys: PublicKey[];
    tier1Connections: PeerInfoView[];
};
type NextEpochValidatorInfo = {
    accountId: AccountId;
    publicKey: PublicKey;
    shards: ShardId[];
    stake: NearToken;
};
type NonceMode = "monotonic" | "strict";
type NonDelegateAction = {
    CreateAccount: CreateAccountAction;
} | {
    DeployContract: DeployContractAction;
} | {
    FunctionCall: FunctionCallAction;
} | {
    Transfer: TransferAction;
} | {
    Stake: StakeAction;
} | {
    AddKey: AddKeyAction;
} | {
    DeleteKey: DeleteKeyAction;
} | {
    DeleteAccount: DeleteAccountAction;
} | {
    DeployGlobalContract: DeployGlobalContractAction;
} | {
    UseGlobalContract: UseGlobalContractAction;
} | {
    DeterministicStateInit: DeterministicStateInitAction;
} | {
    TransferToGasKey: TransferToGasKeyAction;
} | {
    WithdrawFromGasKey: WithdrawFromGasKeyAction;
};
type PeerId = PublicKey;
type PeerInfoView = {
    accountId?: AccountId | (null);
    addr: string;
    archival: boolean;
    blockHash?: CryptoHash | (null);
    /** Format: uint64 */
    connectionEstablishedTimeMillis: number;
    /** Format: uint64 */
    height?: number | null;
    isHighestBlockInvalid: boolean;
    isOutboundPeer: boolean;
    /** Format: uint64 */
    lastTimePeerRequestedMillis: number;
    /** Format: uint64 */
    lastTimeReceivedMessageMillis: number;
    /**
     * Format: uint64
     * @description Connection nonce.
     */
    nonce: number;
    peerId: PublicKey;
    /** Format: uint64 */
    receivedBytesPerSec: number;
    /** Format: uint64 */
    sentBytesPerSec: number;
    trackedShards: ShardId[];
};
type PrepareError = "Serialization" | "Deserialization" | "InternalMemoryDeclared" | "GasInstrumentation" | "StackHeightInstrumentation" | "Instantiate" | "Memory" | "TooManyFunctions" | "TooManyLocals" | "TooManyTables" | "TooManyTableElements" | "FunctionBodyTooLarge" | "InstrumentedCodeTooLarge" | "TooManyBlocksPerFunction" | "TooManyBlocksPerContract" | "TooManyTypes" | "TooManyParamsPerFunction" | "TooManyParamsPerContract" | "OperandStackTooLarge" | "TooManyGlobals";
type ProtocolVersionCheckConfig = "Next" | "NextNext";
type PublicKey = string;
type PublicKeyHandle = string;
type Range_of_uint64 = {
    /** Format: uint64 */
    end: number;
    /** Format: uint64 */
    start: number;
};
type ReceiptEnumView = {
    Action: {
        actions: ActionView[];
        gasPrice: NearToken;
        inputDataIds: CryptoHash[];
        /** @default false */
        isPromiseYield: boolean;
        outputDataReceivers: DataReceiverView[];
        refundTo?: AccountId | (null);
        signerId: AccountId;
        signerPublicKey: PublicKey;
    };
} | {
    Data: {
        /** @default null */
        data: string | null;
        dataId: CryptoHash;
        /** @default false */
        isPromiseResume: boolean;
    };
} | {
    GlobalContractDistribution: {
        alreadyDeliveredShards: ShardId[];
        code: string;
        id: GlobalContractIdentifier;
        /** Format: uint64 */
        nonce?: number | null;
        targetShard: ShardId;
    };
};
type ReceiptValidationError = {
    InvalidPredecessorId: {
        accountId: string;
    };
} | {
    InvalidReceiverId: {
        accountId: string;
    };
} | {
    InvalidSignerId: {
        accountId: string;
    };
} | {
    InvalidDataReceiverId: {
        accountId: string;
    };
} | {
    ReturnedValueLengthExceeded: {
        /** Format: uint64 */
        length: number;
        /** Format: uint64 */
        limit: number;
    };
} | {
    NumberInputDataDependenciesExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        numberOfInputDataDependencies: number;
    };
} | {
    ActionsValidation: ActionsValidationError;
} | {
    ReceiptSizeExceeded: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        size: number;
    };
} | {
    InvalidRefundTo: {
        accountId: string;
    };
};
type ReceiptView = {
    predecessorId: AccountId;
    /**
     * Format: uint64
     * @description Deprecated, retained for backward compatibility.
     * @default 0
     */
    priority: number;
    receipt: ReceiptEnumView;
    receiptId: CryptoHash;
    receiverId: AccountId;
};
type RpcBlockError = {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    /** @enum {string} */
    name: "NOT_SYNCED_YET";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcBlockRequest = {
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
};
type RpcBlockResponse = {
    /** @description The AccountId of the author of the Block */
    author: AccountId;
    chunks: ChunkHeaderView[];
    header: BlockHeaderView;
};
type RpcCallFunctionError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        contractAccountId: AccountId;
    };
    /** @enum {string} */
    name: "NO_CONTRACT_CODE";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        vmError: FunctionCallError;
    };
    /** @enum {string} */
    name: "CONTRACT_EXECUTION_ERROR";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcCallFunctionRequest = {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcCallFunctionResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    logs: string[];
    result: number[];
};
type RpcChunkError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        shardId: ShardId;
    };
    /** @enum {string} */
    name: "INVALID_SHARD_ID";
} | {
    info: {
        chunkHash: ChunkHash;
    };
    /** @enum {string} */
    name: "UNKNOWN_CHUNK";
};
type RpcChunkRequest = {
    blockId: BlockId;
    shardId: ShardId;
} | {
    chunkId: CryptoHash;
};
type RpcChunkResponse = {
    author: AccountId;
    header: ChunkHeaderView;
    receipts: ReceiptView[];
    transactions: SignedTransactionView[];
};
type RpcClientConfigError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcClientConfigRequest = null;
type RpcClientConfigResponse = {
    /** @description Not clear old data, set `true` for archive nodes. */
    archive?: boolean;
    /**
     * Format: uint64
     * @description Behind this horizon header fetch kicks in.
     */
    blockHeaderFetchHorizon?: number;
    /** @description Duration to check for producing / skipping block. */
    blockProductionTrackingDelay?: MutableConfigValue;
    /** @description Time between check to perform catchup. */
    catchupStepPeriod?: number[];
    /** @description Chain id for status. */
    chainId?: string;
    /** @description Optional config for the Chunk Distribution Network feature.
     *     If set to `None` then this node does not participate in the Chunk Distribution Network.
     *     Nodes not participating will still function fine, but possibly with higher
     *     latency due to the need of requesting chunks over the peer-to-peer network. */
    chunkDistributionNetwork?: ChunkDistributionNetworkConfig | (null);
    /** @description Time between checking to re-request chunks. */
    chunkRequestRetryPeriod?: number[];
    /**
     * Format: uint
     * @description Number of threads for ChunkValidationActor pool.
     */
    chunkValidationThreads?: number;
    /** @description Multiplier for the wait time for all chunks to be received. */
    chunkWaitMult?: MutableConfigValue;
    /**
     * Format: uint64
     * @description Height horizon for the chunk cache. A chunk is removed from the cache
     *     if its height + chunks_cache_height_horizon < largest_seen_height.
     *     The default value is DEFAULT_CHUNKS_CACHE_HEIGHT_HORIZON.
     */
    chunksCacheHeightHorizon?: number;
    /**
     * Format: uint
     * @description Number of threads to execute background migration work in client.
     */
    clientBackgroundMigrationThreads?: number;
    /** @description Configuration for a cloud-based archival writer. If this config is present, the writer is enabled and
     *     writes chunk-related data based on the tracked shards. */
    cloudArchivalWriter?: CloudArchivalWriterConfig | (null);
    /** @description If true, the node won't forward transactions to next the chunk producers. */
    disableTxRouting?: boolean;
    /** @description Time between running doomslug timer. */
    doomslugStepPeriod?: MutableConfigValue;
    /** @description If true, transactions for the next chunk will be prepared early, right after the previous chunk's
     *     post-state is ready. This can help produce chunks faster, for high-throughput chains.
     *     The current implementation increases latency on low-load chains, which will be fixed in the future.
     *     The default is disabled. */
    enableEarlyPrepareTransactions?: boolean;
    enableMultilineLogging?: boolean;
    /** @description Re-export storage layer statistics as prometheus metrics. */
    enableStatisticsExport?: boolean;
    /**
     * Format: uint64
     * @description Epoch length.
     */
    epochLength?: number;
    /** @description Options for epoch sync. */
    epochSync?: EpochSyncConfig;
    /** @description Graceful shutdown at expected block height. */
    expectedShutdown?: MutableConfigValue;
    /** @description Garbage collection configuration. */
    gc?: GCConfig;
    /**
     * Format: uint64
     * @description Expected increase of header head height per second during header sync
     */
    headerSyncExpectedHeightPerSecond?: number;
    /** @description How much time to wait after initial header sync */
    headerSyncInitialTimeout?: number[];
    /** @description How much time to wait after some progress is made in header sync */
    headerSyncProgressTimeout?: number[];
    /** @description How much time to wait before banning a peer in header sync if sync is too slow */
    headerSyncStallBanTimeout?: number[];
    /** @description Period between logging summary information. */
    logSummaryPeriod?: number[];
    /** @description Enable coloring of the logs */
    logSummaryStyle?: LogSummaryStyle;
    /** @description Maximum wait for approvals before producing block. */
    maxBlockProductionDelay?: MutableConfigValue;
    /** @description Maximum duration before skipping given height. */
    maxBlockWaitDelay?: MutableConfigValue;
    /** @description Max burnt gas per view method.  If present, overrides value stored in
     *     genesis file.  The value only affects the RPCs without influencing the
     *     protocol thus changing it per-node doesn’t affect the blockchain. */
    maxGasBurntView?: NearGas | (null);
    /** @description Minimum duration before producing block. */
    minBlockProductionDelay?: MutableConfigValue;
    /**
     * Format: uint
     * @description Minimum number of peers to start syncing.
     */
    minNumPeers?: number;
    /**
     * Format: uint64
     * @description Number of block producer seats
     */
    numBlockProducerSeats?: number;
    /**
     * Format: uint64
     * @description Maximum size of state witnesses in the OrphanStateWitnessPool.
     *
     *     We keep only orphan witnesses which are smaller than this size.
     *     This limits the maximum memory usage of OrphanStateWitnessPool.
     */
    orphanStateWitnessMaxSize?: number;
    /**
     * Format: uint
     * @description OrphanStateWitnessPool keeps instances of ChunkStateWitness which can't be processed
     *     because the previous block isn't available. The witnesses wait in the pool until the
     *     required block appears. This variable controls how many witnesses can be stored in the pool.
     */
    orphanStateWitnessPoolSize?: number;
    /** @description Limit the time of adding transactions to a chunk.
     *     A node produces a chunk by adding transactions from the transaction pool until
     *     some limit is reached. This time limit ensures that adding transactions won't take
     *     longer than the specified duration, which helps to produce the chunk quickly. */
    produceChunkAddTransactionsTimeLimit?: string;
    /** @description Produce empty blocks, use `false` for testing. */
    produceEmptyBlocks?: boolean;
    /** @description Determines whether client should exit if the protocol version is not supported
     *     for the next or next next epoch. */
    protocolVersionCheck?: ProtocolVersionCheckConfig;
    /**
     * Format: uint64
     * @description Max `±window` accepted on `EXPERIMENTAL_receipt_to_tx` requests.
     *     Caps caller's `window`. Applies to pre-first-scan `CenterOut`
     *     against caller's literal hint; ancestor scans use
     *     `receipt_to_tx_max_hop_distance` instead. Operators raising this
     *     should also raise `receipt_to_tx_max_hop_distance` so backward reach
     *     matches caller's wider hint scope. Requests with `window` over this
     *     rejected with `WindowTooLarge`.
     */
    receiptToTxMaxHintWindow?: number;
    /**
     * Format: uint64
     * @description Max block-distance ancestor scan walks per hop once any scan in
     *     walk refreshed `current_height`. Subsequent column-miss scans visit
     *     `h, h-1, ..., h-max_hop_distance` from most-recent scan-refreshed
     *     anchor, regardless of column hits between. Anchor included —
     *     same-shard local receipts execute in same block as producing
     *     outcome. Raise if cold archival traffic shows ancestor misses —
     *     gap = scan-refreshed anchor to producer-outcome height of receipt
     *     with missing column row (column hits don't reset anchor). Default
     *     20 (matches `receipt_to_tx_max_hint_window`).
     */
    receiptToTxMaxHopDistance?: number;
    /**
     * Format: uint64
     * @description Per-request ceiling on outcome rows the `EXPERIMENTAL_receipt_to_tx`
     *     hint-fallback scanner reads across hops + shards. Caps cold-RocksDB
     *     worst case on unauthenticated public endpoint. Default 20_000.
     *     Operators serving cold archival traffic with deep walks or sparse
     *     outcomes may raise; benchmark first (see TODO in
     *     `view_client_actor.rs`). Mid-scan exhaustion fails with
     *     `BudgetExceeded { scanned, limit }`.
     */
    receiptToTxMaxOutcomesPerRequest?: number;
    reshardingConfig?: MutableConfigValue;
    /** @description Listening rpc port for status. */
    rpcAddr?: string | null;
    /** @description Save observed instances of invalid ChunkStateWitness to the database in DBCol::InvalidChunkStateWitnesses.
     *     Saving invalid witnesses is useful for analysis and debugging.
     *     This option can cause extra load on the database and is not recommended for production use. */
    saveInvalidWitnesses?: boolean;
    /** @description Save observed instances of ChunkStateWitness to the database in DBCol::LatestChunkStateWitnesses.
     *     Saving the latest witnesses is useful for analysis and debugging.
     *     This option can cause extra load on the database and is not recommended for production use. */
    saveLatestWitnesses?: boolean;
    /** @description Whether to persist receipt-to-tx origin mappings to disk or not. */
    saveReceiptToTx?: boolean;
    /** @description Whether to persist state changes on disk or not. */
    saveStateChanges?: boolean;
    /** @description save_trie_changes should be set to true iff
     *     - archive if false - non-archival nodes need trie changes to perform garbage collection
     *     - archive is true, cold_store is configured and migration to split_storage is finished - node
     *     working in split storage mode needs trie changes in order to do garbage collection on hot. */
    saveTrieChanges?: boolean;
    /** @description Whether to persist transaction outcomes to disk or not. */
    saveTxOutcomes?: boolean;
    /** @description Whether to persist partial chunk parts for untracked shards or not. */
    saveUntrackedPartialChunksParts?: boolean;
    /** @description Skip waiting for sync (for testing or single node testnet). */
    skipSyncWait?: boolean;
    /**
     * Format: uint
     * @description Number of threads for StateRequestActor pool.
     */
    stateRequestServerThreads?: number;
    /** @description Number of seconds between state requests for view client.
     *     Throttling window for state requests (headers and parts). */
    stateRequestThrottlePeriod?: number[];
    /**
     * Format: uint
     * @description Maximum number of state requests served per throttle period
     */
    stateRequestsPerThrottlePeriod?: number;
    /** @description Options for syncing state. */
    stateSync?: StateSyncConfig;
    /** @description How long to wait for a state sync block request response */
    stateSyncExternalTimeout?: number[];
    /** @description How long to wait for a response from p2p state sync */
    stateSyncP2pTimeout?: number[];
    /** @description How long to wait after a failed state sync request */
    stateSyncRetryBackoff?: number[];
    /** @description How often to check that we are not out of sync. */
    syncCheckPeriod?: number[];
    /**
     * Format: uint64
     * @description Sync height threshold: below this difference in height don't start syncing.
     */
    syncHeightThreshold?: number;
    /**
     * Format: uint
     * @description Maximum number of block requests to send to peers to sync
     */
    syncMaxBlockRequests?: number;
    /** @description While syncing, how long to check for each step. */
    syncStepPeriod?: number[];
    trackedShardsConfig?: TrackedShardsConfig;
    /**
     * Format: uint64
     * @description Limit of the size of per-shard transaction pool measured in bytes. If not set, the size
     *     will be unbounded.
     */
    transactionPoolSizeLimit?: number | null;
    /**
     * Format: uint64
     * @description TTL in blocks for gapped strict-nonce transactions in the pool. Transactions with a
     *     nonce gap whose block_hash is older than this many blocks are evicted during
     *     prepare_transactions.
     */
    transactionPoolStrictNonceTtlBlocks?: number;
    /** Format: uint */
    transactionRequestHandlerThreads?: number;
    /**
     * Format: uint64
     * @description Upper bound of the byte size of contract state that is still viewable. None is no limit
     */
    trieViewerStateSizeLimit?: number | null;
    /** @description Time to persist Accounts Id in the router without removing them. */
    ttlAccountIdRouter?: number[];
    /**
     * Format: uint64
     * @description If the node is not a chunk producer within that many blocks, then route
     *     to upcoming chunk producers.
     */
    txRoutingHeightHorizon?: number;
    /** @description Version of the binary. */
    version?: Version;
    /**
     * Format: uint32
     * @description Upper bound on the number of access keys returned by a `view_access_key_list`
     *     query.
     */
    viewAccessKeysLimit?: number;
    /**
     * Format: uint
     * @description Number of threads for ViewClientActor pool.
     */
    viewClientThreads?: number;
};
type RpcCongestionLevelRequest = {
    blockId: BlockId;
    shardId: ShardId;
} | {
    chunkId: CryptoHash;
};
type RpcCongestionLevelResponse = {
    /** Format: double */
    congestionLevel: number;
};
type RpcGasPriceError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
};
type RpcGasPriceRequest = {
    blockId?: BlockId | (null);
};
type RpcGasPriceResponse = {
    gasPrice: NearToken;
};
type RpcHealthRequest = null;
type RpcHealthResponse = null;
type RpcKnownProducer = {
    accountId: AccountId;
    addr?: string | null;
    peerId: PeerId;
};
type RpcLightClientBlockProofRequest = {
    blockHash: CryptoHash;
    lightClientHead: CryptoHash;
};
type RpcLightClientBlockProofResponse = {
    blockHeaderLite: LightClientBlockLiteView;
    blockProof: MerklePathItem[];
};
type RpcLightClientExecutionProofRequest = {
    lightClientHead: CryptoHash;
} & ({
    senderId: AccountId;
    transactionHash: CryptoHash;
    /** @enum {string} */
    type: "transaction";
} | {
    receiptId: CryptoHash;
    receiverId: AccountId;
    /** @enum {string} */
    type: "receipt";
});
type RpcLightClientExecutionProofResponse = {
    blockHeaderLite: LightClientBlockLiteView;
    blockProof: MerklePathItem[];
    outcomeProof: ExecutionOutcomeWithIdView;
    outcomeRootProof: MerklePathItem[];
};
type RpcLightClientNextBlockError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        epochId: EpochId;
    };
    /** @enum {string} */
    name: "EPOCH_OUT_OF_BOUNDS";
};
type RpcLightClientNextBlockRequest = {
    lastBlockHash: CryptoHash;
};
type RpcLightClientNextBlockResponse = {
    approvalsAfterNext?: (Signature | (null))[];
    /** @description Inner part of the block header that gets hashed, split into two parts, one that is sent
     *        to light clients, and the rest */
    innerLite?: BlockHeaderInnerLiteView;
    innerRestHash?: CryptoHash;
    nextBlockInnerHash?: CryptoHash;
    nextBps?: ValidatorStakeView[] | null;
    prevBlockHash?: CryptoHash;
};
type RpcLightClientProofError = {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        executionOutcomeShardId: ShardId;
        /** Format: uint */
        numberOrShards: number;
    };
    /** @enum {string} */
    name: "INCONSISTENT_STATE";
} | {
    info: {
        transactionOrReceiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "NOT_CONFIRMED";
} | {
    info: {
        transactionOrReceiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "UNKNOWN_TRANSACTION_OR_RECEIPT";
} | {
    info: {
        shardId: ShardId;
        transactionOrReceiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "UNAVAILABLE_SHARD";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcMaintenanceWindowsError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcMaintenanceWindowsRequest = {
    accountId: AccountId;
};
type RpcNetworkInfoError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcNetworkInfoRequest = null;
type RpcNetworkInfoResponse = {
    activePeers: RpcPeerInfo[];
    /** @description Accounts of known block and chunk producers from routing table. */
    knownProducers: RpcKnownProducer[];
    /** Format: uint */
    numActivePeers: number;
    /** Format: uint32 */
    peerMaxCount: number;
    /** Format: uint64 */
    receivedBytesPerSec: number;
    /** Format: uint64 */
    sentBytesPerSec: number;
};
type RpcPeerInfo = {
    accountId?: AccountId | (null);
    addr?: string | null;
    id: PeerId;
};
type RpcProtocolConfigError = {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcProtocolConfigRequest = {
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
};
type RpcProtocolConfigResponse = {
    /**
     * Format: uint8
     * @description Threshold for kicking out block producers, between 0 and 100.
     */
    blockProducerKickoutThreshold?: number;
    /** @description ID of the blockchain. This must be unique for every blockchain.
     *     If your testnet blockchains do not have unique chain IDs, you will have a bad time. */
    chainId?: string;
    /**
     * Format: uint8
     * @description Threshold for kicking out chunk producers, between 0 and 100.
     */
    chunkProducerKickoutThreshold?: number;
    /**
     * Format: uint8
     * @description Threshold for kicking out nodes which are only chunk validators, between 0 and 100.
     */
    chunkValidatorOnlyKickoutThreshold?: number;
    /** @description Enable dynamic re-sharding. */
    dynamicResharding?: boolean;
    /**
     * Format: uint64
     * @description Epoch length counted in block heights.
     */
    epochLength?: number;
    /** @description Fishermen stake threshold. */
    fishermenThreshold?: NearToken;
    /** @description Initial gas limit. */
    gasLimit?: NearGas;
    /** @description Gas price adjustment rate */
    gasPriceAdjustmentRate?: number[];
    /**
     * Format: uint64
     * @description Height of genesis block.
     */
    genesisHeight?: number;
    /**
     * Format: date-time
     * @description Official time of blockchain start.
     */
    genesisTime?: string;
    /** @description Maximum gas price. */
    maxGasPrice?: NearToken;
    /** @description Maximum inflation on the total supply every epoch. */
    maxInflationRate?: number[];
    /**
     * Format: uint8
     * @description Max stake percentage of the validators we will kick out.
     */
    maxKickoutStakePerc?: number;
    /** @description Minimum gas price. It is also the initial gas price. */
    minGasPrice?: NearToken;
    /**
     * Format: uint64
     * @description The minimum stake required for staking is last seat price divided by this number.
     */
    minimumStakeDivisor?: number;
    /** @description The lowest ratio s/s_total any block producer can have.
     *     See <https://github.com/near/NEPs/pull/167> for details */
    minimumStakeRatio?: number[];
    /**
     * Format: uint64
     * @description The minimum number of validators each shard must have
     */
    minimumValidatorsPerShard?: number;
    /**
     * Format: uint64
     * @description Number of block producer seats at genesis.
     */
    numBlockProducerSeats?: number;
    /**
     * Format: uint64
     * @description Expected number of blocks per year
     */
    numBlocksPerYear?: number;
    /** @description Online maximum threshold above which validator gets full reward. */
    onlineMaxThreshold?: number[];
    /** @description Online minimum threshold below which validator doesn't receive reward. */
    onlineMinThreshold?: number[];
    /** @description Protocol treasury rate */
    protocolRewardRate?: number[];
    /** @description Protocol treasury account */
    protocolTreasuryAccount?: AccountId;
    /** @description Threshold of stake that needs to indicate that they ready for upgrade. */
    protocolUpgradeStakeThreshold?: number[];
    /**
     * Format: uint32
     * @description Current Protocol Version
     */
    protocolVersion?: number;
    /** @description Runtime configuration (mostly economics constants). */
    runtimeConfig?: RuntimeConfigView;
    /** @description Layout information regarding how to split accounts to shards */
    shardLayout?: ShardLayout;
    /** @description If true, shuffle the chunk producers across shards. In other words, if
     *     the shard assignments were `[S_0, S_1, S_2, S_3]` where `S_i` represents
     *     the set of chunk producers for shard `i`, if this flag were true, the
     *     shard assignments might become, for example, `[S_2, S_0, S_3, S_1]`. */
    shuffleShardAssignmentForChunkProducers?: boolean;
    /**
     * Format: uint64
     * @description Number of target chunk validator mandates for each shard.
     */
    targetValidatorMandatesPerShard?: number;
    /**
     * Format: uint64
     * @description Number of blocks for which a given transaction is valid
     */
    transactionValidityPeriod?: number;
};
type RpcQueryError = {
    /** @enum {string} */
    name: "NO_SYNCED_BLOCKS";
} | {
    info: {
        requestedShardId: ShardId;
    };
    /** @enum {string} */
    name: "UNAVAILABLE_SHARD";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    };
    /** @enum {string} */
    name: "GARBAGE_COLLECTED_BLOCK";
} | {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        contractAccountId: AccountId;
    };
    /** @enum {string} */
    name: "NO_CONTRACT_CODE";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        contractAccountId: AccountId;
    };
    /** @enum {string} */
    name: "TOO_LARGE_CONTRACT_STATE";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        publicKey: PublicKey;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCESS_KEY";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        publicKey: PublicKey;
    };
    /** @enum {string} */
    name: "UNKNOWN_GAS_KEY";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        /** Format: uint32 */
        limit: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "TOO_MANY_ACCESS_KEYS";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        error: FunctionCallError;
        vmError: string;
    };
    /** @enum {string} */
    name: "CONTRACT_EXECUTION_ERROR";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        identifier: GlobalContractIdentifier;
    };
    /** @enum {string} */
    name: "NO_GLOBAL_CONTRACT_CODE";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcQueryRequest = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
}) | ({
    blockId: BlockId;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
}) | ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
}) | ({
    finality: Finality;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
});
type RpcQueryResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
} & (AccountView | ContractCodeView | ViewStateResult | CallResult | AccessKeyView | AccessKeyList | GasKeyNoncesView);
type RpcReceiptError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info: {
        receiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "UNKNOWN_RECEIPT";
};
type RpcReceiptRequest = {
    receiptId: CryptoHash;
};
type RpcReceiptResponse = {
    predecessorId: AccountId;
    /**
     * Format: uint64
     * @description Deprecated, retained for backward compatibility.
     * @default 0
     */
    priority: number;
    receipt: ReceiptEnumView;
    receiptId: CryptoHash;
    receiverId: AccountId;
};
type RpcReceiptToTxError = {
    info: {
        receiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "UNKNOWN_RECEIPT";
} | {
    info: {
        /** Format: uint32 */
        limit: number;
        receiptId: CryptoHash;
    };
    /** @enum {string} */
    name: "DEPTH_EXCEEDED";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "UNSUPPORTED";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    /** @enum {string} */
    name: "OUTCOMES_NOT_STORED";
} | {
    info: {
        /** Format: uint64 */
        maximum: number;
        /** Format: uint64 */
        requested: number;
    };
    /** @enum {string} */
    name: "WINDOW_TOO_LARGE";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "MALFORMED_HINT";
} | {
    info: {
        /** Format: uint64 */
        limit: number;
        /** Format: uint64 */
        scanned: number;
    };
    /** @enum {string} */
    name: "BUDGET_EXCEEDED";
};
type RpcReceiptToTxRequest = {
    /**
     * Format: uint64
     * @description Block height near where receipt was created. Enables hint fallback
     *     scan on column miss. Anchor refreshes to each scan-resolved parent's
     *     exact execution height; later ancestors bounded via causality
     *     (emit before execute), so subsequent column-miss scans go
     *     `Ancestor`. Bump `receipt_to_tx_max_hop_distance` if cold archival
     *     gaps exceed default 20.
     *
     *     Cold-storage cost: per-row latency orders of magnitude over hot. To
     *     bound request cost:
     *       - Supply `block_height` within parent's `±window` (default 5).
     *       - Supply `shard_id`. Omit → all-shards enumeration until walker
     *         crosses `FromReceipt` hop, multiplying cold-read cost.
     *       - Don't widen `window` beyond indexer's accuracy; budget shared
     *         across full ancestry walk.
     *
     *     Receipt-id-only queries against periods with `save_receipt_to_tx`
     *     disabled stay unsupported: column never written, no self-locating.
     */
    blockHeight?: number | null;
    receiptId: CryptoHash;
    /** @description Shard hint. Narrows scan to this shard at hint height. Omit to
     *     enumerate all tracked shards (higher cost). After walker crosses a
     *     receipt-origin hop, shard derived from parent's predecessor account
     *     and hint no longer applies. Best-effort across resharding: layout
     *     shifts can miss producer, walk returns `UnknownReceipt`. */
    shardId?: ShardId | (null);
    /**
     * Format: uint64
     * @description Pre-first-scan width: `±window` heights around hint. Caps at
     *     `receipt_to_tx_max_hint_window` (default 20). Ignored after first
     *     scan-resolved hop — walker switches to `Ancestor` mode at
     *     `receipt_to_tx_max_hop_distance` width.
     */
    window?: number | null;
};
type RpcReceiptToTxResponse = {
    senderAccountId: AccountId;
    transactionHash: CryptoHash;
};
type RpcRequestValidationErrorKind = {
    info: {
        methodName: string;
    };
    /** @enum {string} */
    name: "METHOD_NOT_FOUND";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "PARSE_ERROR";
};
type RpcSendTransactionRequest = {
    signedTxBase64: SignedTransaction;
    /** @default EXECUTED_OPTIMISTIC */
    waitUntil: TxExecutionStatus;
};
type RpcSplitStorageInfoError = {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcSplitStorageInfoRequest = Record<string, unknown>;
type RpcSplitStorageInfoResponse = {
    /** Format: uint64 */
    coldHeadHeight?: number | null;
    /** Format: uint64 */
    finalHeadHeight?: number | null;
    /** Format: uint64 */
    headHeight?: number | null;
    hotDbKind?: string | null;
};
type RpcStateChangesError = {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    /** @enum {string} */
    name: "NOT_SYNCED_YET";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info: {
        shardId: ShardId;
    };
    /** @enum {string} */
    name: "SHARD_NOT_APPLIED";
};
type RpcStateChangesInBlockByTypeRequest = ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
}) | ({
    blockId: BlockId;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
}) | ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
}) | ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
}) | ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
}) | ({
    finality: Finality;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
});
type RpcStateChangesInBlockByTypeResponse = {
    blockHash: CryptoHash;
    changes: StateChangeKindView[];
};
type RpcStateChangesInBlockRequest = {
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
};
type RpcStateChangesInBlockResponse = {
    blockHash: CryptoHash;
    changes: StateChangeWithCauseView[];
};
type RpcStatusError = {
    /** @enum {string} */
    name: "NODE_IS_SYNCING";
} | {
    info: {
        elapsed: number[];
    };
    /** @enum {string} */
    name: "NO_NEW_BLOCKS";
} | {
    info: {
        epochId: EpochId;
    };
    /** @enum {string} */
    name: "EPOCH_OUT_OF_BOUNDS";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcStatusRequest = null;
type RpcStatusResponse = {
    /** @description Unique chain id. */
    chainId: string;
    /** @description Information about last blocks, network, epoch and chain & chunk info. */
    detailedDebugStatus?: DetailedDebugStatus | (null);
    /** @description Genesis hash of the chain. */
    genesisHash: CryptoHash;
    /**
     * Format: uint32
     * @description Latest protocol version that this client supports.
     */
    latestProtocolVersion: number;
    /** @description Deprecated; same as `validator_public_key` which you should use instead. */
    nodeKey?: PublicKey | (null);
    /** @description Public key of the node. */
    nodePublicKey: PublicKey;
    /**
     * Format: uint32
     * @description Currently active protocol version.
     */
    protocolVersion: number;
    /** @description Address for RPC server.  None if node doesn't have RPC endpoint enabled. */
    rpcAddr?: string | null;
    /** @description Sync status of the node. */
    syncInfo: StatusSyncInfo;
    /**
     * Format: int64
     * @description Uptime of the node.
     */
    uptimeSec: number;
    /** @description Validator id of the node */
    validatorAccountId?: AccountId | (null);
    /** @description Public key of the validator. */
    validatorPublicKey?: PublicKey | (null);
    /** @description Current epoch validators. */
    validators: ValidatorInfo[];
    /** @description Binary version. */
    version: Version;
};
type RpcTransactionError = {
    info: Record<string, unknown>;
    /** @enum {string} */
    name: "INVALID_TRANSACTION";
} | {
    /** @enum {string} */
    name: "DOES_NOT_TRACK_SHARD";
} | {
    info: {
        transactionHash: CryptoHash;
    };
    /** @enum {string} */
    name: "REQUEST_ROUTED";
} | {
    info: {
        requestedTransactionHash: CryptoHash;
    };
    /** @enum {string} */
    name: "UNKNOWN_TRANSACTION";
} | {
    info: {
        debugInfo: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
} | {
    info?: TimeoutErrorCause | (null);
    /** @enum {string} */
    name: "TIMEOUT_ERROR";
};
type RpcTransactionResponse = {
    finalExecutionStatus: TxExecutionStatus;
} & (FinalExecutionOutcomeWithReceiptView | FinalExecutionOutcomeView);
type RpcTransactionStatusRequest = {
    /** @default EXECUTED_OPTIMISTIC */
    waitUntil: TxExecutionStatus;
} & ({
    signedTxBase64: SignedTransaction;
} | {
    senderAccountId: AccountId;
    txHash: CryptoHash;
});
type RpcValidatorError = {
    /** @enum {string} */
    name: "UNKNOWN_EPOCH";
} | {
    /** @enum {string} */
    name: "VALIDATOR_INFO_UNAVAILABLE";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcValidatorRequest = {
    epochId: EpochId;
} | {
    blockId: BlockId;
} | {
    /** @enum {unknown|null} */
    latest: null;
};
type RpcValidatorResponse = {
    /** @description Fishermen for the current epoch */
    currentFishermen: ValidatorStakeView[];
    /** @description Proposals in the current epoch */
    currentProposals: ValidatorStakeView[];
    /** @description Validators for the current epoch */
    currentValidators: CurrentEpochValidatorInfo[];
    /**
     * Format: uint64
     * @description Epoch height
     */
    epochHeight: number;
    /**
     * Format: uint64
     * @description Epoch start block height
     */
    epochStartHeight: number;
    /** @description Fishermen for the next epoch */
    nextFishermen: ValidatorStakeView[];
    /** @description Validators for the next epoch */
    nextValidators: NextEpochValidatorInfo[];
    /** @description Kickout in the previous epoch */
    prevEpochKickout: ValidatorKickoutView[];
    /**
     * @description Per-validator rewards paid out at the start of the previous epoch.
     *     For epoch E, this contains the rewards earned in epoch E-2 that were
     *     added to validator and treasury balances at the first block of epoch
     *     E-1 (via `ValidatorAccountsUpdate`).
     * @default {}
     */
    validatorRewardPaidPrevEpoch: {
        [key: string]: NearToken;
    };
};
type RpcValidatorsOrderedRequest = {
    blockId?: BlockId | (null);
};
type RpcViewAccessKeyError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        publicKey: PublicKey;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCESS_KEY";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcViewAccessKeyListError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcViewAccessKeyListRequest = {
    accountId: AccountId;
    /** @description Pagination cursor: resume the listing strictly after this access key.
     *     Pass the `last_key` returned by the previous page. */
    afterKey?: PublicKeyHandle | (null);
    /**
     * Format: uint32
     * @description Maximum number of access keys to return in this page.
     */
    limit?: number | null;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcViewAccessKeyListResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    keys: AccessKeyInfoView[];
    /** @description Pagination cursor. When `Some`, the listing was truncated and the caller
     *     should issue another request with `after_key` set to this handle to fetch
     *     the next page. `None` means this was the last page. */
    lastKey?: PublicKeyHandle | (null);
};
type RpcViewAccessKeyRequest = {
    accountId: AccountId;
    publicKey: PublicKey;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcViewAccessKeyResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    /**
     * Format: uint64
     * @description Current nonce; each transaction signed with this key must use a strictly greater value.
     */
    nonce: number;
    /** @description Access scope: full access, or a function-call permission with an optional allowance and method/receiver limits. */
    permission: AccessKeyPermissionView;
};
type RpcViewAccountError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcViewAccountRequest = {
    accountId: AccountId;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcViewAccountResponse = {
    /** @description Liquid (non-staked) account balance, in yoctoNEAR. */
    amount: NearToken;
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    /** @description Hash of the deployed contract code; the all-`1`s hash when no contract is deployed. */
    codeHash: CryptoHash;
    /** @description Set when the account uses a global contract referenced by the deploying account id. */
    globalContractAccountId?: AccountId | (null);
    /** @description Set when the account uses a global contract referenced by code hash. */
    globalContractHash?: CryptoHash | (null);
    /** @description Staked balance locked for validation, in yoctoNEAR. */
    locked: NearToken;
    /**
     * Format: uint64
     * @description Deprecated and unused. TODO(2271): remove.
     * @default 0
     */
    storagePaidAt: number;
    /**
     * Format: uint64
     * @description Total storage used by the account, in bytes.
     */
    storageUsage: number;
};
type RpcViewCodeError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        contractAccountId: AccountId;
    };
    /** @enum {string} */
    name: "NO_CONTRACT_CODE";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcViewCodeRequest = {
    accountId: AccountId;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcViewCodeResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    codeBase64: string;
    hash: CryptoHash;
};
type RpcViewStateError = {
    info: {
        blockReference: BlockReference;
    };
    /** @enum {string} */
    name: "UNKNOWN_BLOCK";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "INVALID_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        requestedAccountId: AccountId;
    };
    /** @enum {string} */
    name: "UNKNOWN_ACCOUNT";
} | {
    info: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
        contractAccountId: AccountId;
    };
    /** @enum {string} */
    name: "TOO_LARGE_CONTRACT_STATE";
} | {
    info: {
        errorMessage: string;
    };
    /** @enum {string} */
    name: "INTERNAL_ERROR";
};
type RpcViewStateRequest = {
    accountId: AccountId;
    /**
     * @description Resume listing after this key (exclusive); must start with `prefix`.
     * @default null
     */
    afterKeyBase64: StoreKey | (null);
    /** @default false */
    includeProof: boolean;
    /**
     * Format: uint32
     * @description Maximum number of entries to return in this page.
     * @default null
     */
    limit: number | null;
    prefixBase64: StoreKey;
} & ({
    blockId: BlockId;
} | {
    finality: Finality;
} | {
    syncCheckpoint: SyncCheckpoint;
});
type RpcViewStateResponse = {
    blockHash: CryptoHash;
    /** Format: uint64 */
    blockHeight: number;
    /** @description Cursor to resume from: present when more entries remain, absent when the listing is complete. */
    lastKey?: StoreKey | (null);
    proof?: string[];
    values: StateItem[];
};
type RuntimeConfigView = {
    /**
     * @description How much creating an account should cost in NEAR. Taken into account when burning gas for
     *     account creation.
     * @default 0
     */
    accountCreationCharge: NearToken;
    /** @description Config that defines rules for account creation. */
    accountCreationConfig?: AccountCreationConfigView;
    /** @description The configuration for congestion control. */
    congestionControlConfig?: CongestionControlConfigView;
    /**
     * @description Minimum price at which the gas attached to a receipt is purchased. The price at which it is
     *     burned might be lower, in which case the difference is refunded after execution.
     * @default 0
     */
    minGasPurchasePrice: NearToken;
    /** @description Amount of yN per byte required to have on the account.  See
     *     <https://nomicon.io/Economics/Economics.html#state-stake> for details. */
    storageAmountPerByte?: NearToken;
    /** @description Costs of different actions that need to be performed when sending and
     *     processing transaction and receipts. */
    transactionCosts?: RuntimeFeesConfigView;
    /** @description Config of wasm operations. */
    wasmConfig?: VMConfigView;
    /** @description Configuration specific to ChunkStateWitness. */
    witnessConfig?: WitnessConfigView;
};
type RuntimeFeesConfigView = {
    /** @description Describes the cost of creating a certain action, `Action`. Includes all variants. */
    actionCreationConfig?: ActionCreationConfigView;
    /** @description Describes the cost of creating an action receipt, `ActionReceipt`, excluding the actual cost
     *     of actions.
     *     - `send` cost is burned when a receipt is created using `promise_create` or
     *         `promise_batch_create`
     *     - `exec` cost is burned when the receipt is being executed. */
    actionReceiptCreationConfig?: Fee;
    /** @description Fraction of the burnt gas to reward to the contract account for execution. */
    burntGasReward?: number[];
    /** @description Describes the cost of creating a data receipt, `DataReceipt`. */
    dataReceiptCreationConfig?: DataReceiptCreationConfigView;
    /** @description Describes the extra cost of verifying an ML-DSA-65 signature above the
     *     cost of verifying the standard signature types. */
    mlDsa65VerificationCost?: NearGas;
    /** @description Pessimistic gas price inflation ratio. */
    pessimisticGasPriceInflationRatio?: number[];
    /** @description Describes fees for storage. */
    storageUsageConfig?: StorageUsageConfigView;
};
type ShardId = number;
type ShardLayout = {
    V0: ShardLayoutV0;
} | {
    V1: ShardLayoutV1;
} | {
    V2: ShardLayoutV2;
} | {
    V3: ShardLayoutV3;
};
type ShardLayoutV0 = {
    /**
     * Format: uint64
     * @description Map accounts evenly across all shards
     */
    numShards: number;
    /**
     * Format: uint32
     * @description Version of the shard layout, this is useful for uniquely identify the shard layout
     */
    version: number;
};
type ShardLayoutV1 = {
    /** @description The boundary accounts are the accounts on boundaries between shards.
     *     Each shard contains a range of accounts from one boundary account to
     *     another - or the smallest or largest account possible. The total
     *     number of shards is equal to the number of boundary accounts plus 1. */
    boundaryAccounts: AccountId[];
    /** @description Maps shards from the last shard layout to shards that it splits to in this shard layout,
     *     Useful for constructing states for the shards.
     *     None for the genesis shard layout */
    shardsSplitMap?: ShardId[][] | null;
    /** @description Maps shard in this shard layout to their parent shard
     *     Since shard_ids always range from 0 to num_shards - 1, we use vec instead of a hashmap */
    toParentShardMap?: ShardId[] | null;
    /**
     * Format: uint32
     * @description Version of the shard layout, this is useful for uniquely identify the shard layout
     */
    version: number;
};
type ShardLayoutV2 = {
    boundaryAccounts: AccountId[];
    idToIndexMap: {
        [key: string]: number;
    };
    indexToIdMap: {
        [key: string]: ShardId;
    };
    shardIds: ShardId[];
    shardsParentMap?: {
        [key: string]: ShardId;
    } | null;
    shardsSplitMap?: {
        [key: string]: ShardId[];
    } | null;
    /** Format: uint32 */
    version: number;
};
type ShardLayoutV3 = {
    boundaryAccounts: AccountId[];
    idToIndexMap: {
        [key: string]: number;
    };
    lastSplit: ShardId;
    shardIds: ShardId[];
    shardsSplitMap: {
        [key: string]: ShardId[];
    };
};
type ShardUId = {
    /** Format: uint32 */
    shardId: number;
    /** Format: uint32 */
    version: number;
};
type Signature = string;
type SignedDelegateAction = {
    delegateAction: DelegateAction;
    signature: Signature;
};
type SignedTransaction = string;
type SignedTransactionView = {
    actions: ActionView[];
    hash: CryptoHash;
    /** Format: uint64 */
    nonce: number;
    /** Format: uint16 */
    nonceIndex?: number | null;
    nonceMode?: NonceMode | (null);
    /**
     * Format: uint64
     * @description Deprecated, retained for backward compatibility.
     * @default 0
     */
    priorityFee: number;
    publicKey: PublicKey;
    receiverId: AccountId;
    signature: Signature;
    signerId: AccountId;
};
type SlashedValidator = {
    accountId: AccountId;
    isDoubleSign: boolean;
};
type SpiceChunkEndorsementStats = {
    /** Format: uint32 */
    expected: number;
    /** Format: uint32 */
    produced: number;
};
type StakeAction = {
    /** @description Validator key which will be used to sign transactions on behalf of signer_id */
    publicKey: PublicKey;
    /** @description Amount of tokens to stake. */
    stake: NearToken;
};
type StateChangeCauseView = {
    /** @enum {string} */
    type: "not_writable_to_disk";
} | {
    /** @enum {string} */
    type: "initial_state";
} | {
    txHash: CryptoHash;
    /** @enum {string} */
    type: "transaction_processing";
} | {
    receiptHash: CryptoHash;
    /** @enum {string} */
    type: "action_receipt_processing_started";
} | {
    receiptHash: CryptoHash;
    /** @enum {string} */
    type: "action_receipt_gas_reward";
} | {
    receiptHash: CryptoHash;
    /** @enum {string} */
    type: "receipt_processing";
} | {
    receiptHash: CryptoHash;
    /** @enum {string} */
    type: "postponed_receipt";
} | {
    /** @enum {string} */
    type: "updated_delayed_receipts";
} | {
    /** @enum {string} */
    type: "validator_accounts_update";
} | {
    /** @enum {string} */
    type: "migration";
} | {
    /** @enum {string} */
    type: "bandwidth_scheduler_state_update";
};
type StateChangeKindView = {
    accountId: AccountId;
    /** @enum {string} */
    type: "account_touched";
} | {
    accountId: AccountId;
    /** @enum {string} */
    type: "access_key_touched";
} | {
    accountId: AccountId;
    /** @enum {string} */
    type: "data_touched";
} | {
    accountId: AccountId;
    /** @enum {string} */
    type: "contract_code_touched";
};
type StateChangeWithCauseView = {
    cause: StateChangeCauseView;
} & ({
    /** @description A view of the account */
    change: {
        accountId: AccountId;
        /** @description Liquid (non-staked) account balance, in yoctoNEAR. */
        amount: NearToken;
        /** @description Hash of the deployed contract code; the all-`1`s hash when no contract is deployed. */
        codeHash: CryptoHash;
        /** @description Set when the account uses a global contract referenced by the deploying account id. */
        globalContractAccountId?: AccountId | (null);
        /** @description Set when the account uses a global contract referenced by code hash. */
        globalContractHash?: CryptoHash | (null);
        /** @description Staked balance locked for validation, in yoctoNEAR. */
        locked: NearToken;
        /**
         * Format: uint64
         * @description Deprecated and unused. TODO(2271): remove.
         * @default 0
         */
        storagePaidAt: number;
        /**
         * Format: uint64
         * @description Total storage used by the account, in bytes.
         */
        storageUsage: number;
    };
    /** @enum {string} */
    type: "account_update";
} | {
    change: {
        accountId: AccountId;
    };
    /** @enum {string} */
    type: "account_deletion";
} | {
    change: {
        accessKey: AccessKeyView;
        accountId: AccountId;
        publicKey: PublicKeyHandle;
    };
    /** @enum {string} */
    type: "access_key_update";
} | {
    change: {
        accountId: AccountId;
        publicKey: PublicKeyHandle;
    };
    /** @enum {string} */
    type: "access_key_deletion";
} | {
    change: {
        accountId: AccountId;
        /** Format: uint16 */
        index: number;
        /** Format: uint64 */
        nonce: number;
        publicKey: PublicKeyHandle;
    };
    /** @enum {string} */
    type: "gas_key_nonce_update";
} | {
    change: {
        accountId: AccountId;
        keyBase64: StoreKey;
        valueBase64: StoreValue;
    };
    /** @enum {string} */
    type: "data_update";
} | {
    change: {
        accountId: AccountId;
        keyBase64: StoreKey;
    };
    /** @enum {string} */
    type: "data_deletion";
} | {
    change: {
        accountId: AccountId;
        codeBase64: string;
    };
    /** @enum {string} */
    type: "contract_code_update";
} | {
    change: {
        accountId: AccountId;
    };
    /** @enum {string} */
    type: "contract_code_deletion";
});
type StateItem = {
    key: StoreKey;
    value: StoreValue;
};
type StateSyncConfig = {
    concurrency?: SyncConcurrency;
    /** @description `none` value disables state dump to external storage. */
    dump?: DumpConfig | (null);
    /**
     * Format: int32
     * @description Zstd compression level for state parts.
     * @default 1
     */
    partsCompressionLvl: number;
    sync?: SyncConfig;
};
type StatusSyncInfo = {
    earliestBlockHash?: CryptoHash | (null);
    /** Format: uint64 */
    earliestBlockHeight?: number | null;
    earliestBlockTime?: string | null;
    epochId?: EpochId | (null);
    /** Format: uint64 */
    epochStartHeight?: number | null;
    latestBlockHash: CryptoHash;
    /** Format: uint64 */
    latestBlockHeight: number;
    latestBlockTime: string;
    latestStateRoot: CryptoHash;
    syncing: boolean;
};
type StorageError = "StorageInternalError" | {
    MissingTrieValue: MissingTrieValue;
} | "UnexpectedTrieValue" | {
    StorageInconsistentState: string;
} | {
    FlatStorageBlockNotSupported: string;
} | {
    MemTrieLoadingError: string;
};
type StorageGetMode = "FlatStorage" | "Trie";
type StorageUsageConfigView = {
    /**
     * Format: uint64
     * @description Number of bytes for an account record, including rounding up for account id.
     */
    numBytesAccount?: number;
    /**
     * Format: uint64
     * @description Additional number of bytes for a k/v record
     */
    numExtraBytesRecord?: number;
};
type StoreKey = string;
type StoreValue = string;
type SyncCheckpoint = "genesis" | "earliest_available";
type SyncConcurrency = {
    /**
     * Format: uint8
     * @description Maximum number of "apply parts" tasks that can be performed in parallel.
     *     This is a very disk-heavy task and therefore we set this to a low limit,
     *     or else the rocksdb contention makes the whole server freeze up.
     */
    apply?: number;
    /**
     * Format: uint8
     * @description Maximum number of "apply parts" tasks that can be performed in parallel
     *     during catchup. We set this to a very low value to avoid overloading the
     *     node while it is still performing normal tasks.
     */
    applyDuringCatchup?: number;
    /**
     * Format: uint8
     * @description Maximum number of outstanding requests for decentralized state sync.
     */
    peerDownloads?: number;
    /**
     * Format: uint8
     * @description The maximum parallelism to use per shard. This is mostly for fairness, because
     *     the actual rate limiting is done by the TaskTrackers, but this is useful for
     *     balancing the shards a little.
     */
    perShard?: number;
};
type SyncConfig = "Peers";
type Tier1ProxyView = {
    addr: string;
    peerId: PublicKey;
};
type TimeoutErrorCause = {
    /** @enum {string} */
    cause: "NOT_OBSERVED";
} | {
    /** @enum {string} */
    cause: "PENDING";
    status: RpcTransactionResponse;
} | {
    /** @enum {string} */
    cause: "DOES_NOT_TRACK_SHARD";
    shardId: ShardId;
} | {
    /** @enum {string} */
    cause: "ERROR";
    debugInfo: string;
};
type TrackedShardsConfig = "NoShards" | {
    Shards: ShardUId[];
} | "AllShards" | {
    ShadowValidator: AccountId;
} | {
    Schedule: ShardId[][];
} | {
    Accounts: AccountId[];
};
type TransactionNonce = {
    Nonce: {
        /** Format: uint64 */
        nonce: number;
    };
} | {
    GasKeyNonce: {
        /** Format: uint64 */
        nonce: number;
        /** Format: uint16 */
        nonceIndex: number;
    };
};
type TransferAction = {
    deposit: NearToken;
};
type TransferToGasKeyAction = {
    /** @description Amount of NEAR to transfer to the gas key */
    deposit: NearToken;
    /** @description The public key of the gas key to fund */
    publicKey: PublicKey;
};
type TrieSplit = {
    /** @description Account ID representing the split path */
    boundaryAccount: AccountId;
    /**
     * Format: uint64
     * @description Total `memory_usage` of the left part (excluding the split path)
     */
    leftMemory: number;
    /**
     * Format: uint64
     * @description Total `memory_usage` of the right part (including the split path)
     */
    rightMemory: number;
};
type TxExecutionError = {
    ActionError: ActionError;
} | {
    InvalidTxError: InvalidTxError;
};
type TxExecutionStatus = "NONE" | "INCLUDED" | "EXECUTED_OPTIMISTIC" | "INCLUDED_FINAL" | "EXECUTED" | "FINAL";
type UseGlobalContractAction = {
    contractIdentifier: GlobalContractIdentifier;
};
type ValidatorInfo = {
    accountId: AccountId;
};
type ValidatorKickoutReason = "_UnusedSlashed" | {
    NotEnoughBlocks: {
        /** Format: uint64 */
        expected: number;
        /** Format: uint64 */
        produced: number;
    };
} | {
    NotEnoughChunks: {
        /** Format: uint64 */
        expected: number;
        /** Format: uint64 */
        produced: number;
    };
} | "Unstaked" | {
    NotEnoughStake: {
        stakeU128: NearToken;
        thresholdU128: NearToken;
    };
} | "DidNotGetASeat" | {
    NotEnoughChunkEndorsements: {
        /** Format: uint64 */
        expected: number;
        /** Format: uint64 */
        produced: number;
    };
} | {
    ProtocolVersionTooOld: {
        /** Format: uint32 */
        networkVersion: number;
        /** Format: uint32 */
        version: number;
    };
};
type ValidatorKickoutView = {
    accountId: AccountId;
    reason: ValidatorKickoutReason;
};
type ValidatorStakeView = {
    /** @enum {string} */
    validatorStakeStructVersion: "V1";
} & ValidatorStakeViewV1;
type ValidatorStakeViewV1 = {
    accountId: AccountId;
    publicKey: PublicKey;
    stake: NearToken;
};
type Version = {
    build: string;
    commit: string;
    /** @default  */
    rustcVersion: string;
    version: string;
};
type VersionedDelegateActionPayload = {
    V2: DelegateActionV2;
};
type VersionedSignedDelegateAction = {
    delegateAction: VersionedDelegateActionPayload;
    signature: Signature;
};
type ViewStateResult = {
    /** @description Cursor to resume from: present when more entries remain, absent when the listing is complete. */
    lastKey?: StoreKey | (null);
    proof?: string[];
    values: StateItem[];
};
type VMConfigView = {
    /** @description See [VMConfig::bls12381_not_in_group_fix](crate::vm::Config::bls12381_not_in_group_fix). */
    bls12381NotInGroupFix?: boolean;
    /** @description See [VMConfig::chain_id_host_fn](crate::vm::Config::chain_id_host_fn). */
    chainIdHostFn?: boolean;
    /** @description See [VMConfig::discard_custom_sections](crate::vm::Config::discard_custom_sections). */
    discardCustomSections?: boolean;
    /** @description See [VMConfig::eth_implicit_accounts](crate::vm::Config::eth_implicit_accounts). */
    ethImplicitAccounts?: boolean;
    /** @description Costs for runtime externals */
    extCosts?: ExtCostsConfigView;
    /** @description See [VMConfig::fix_contract_loading_cost](crate::vm::Config::fix_contract_loading_cost). */
    fixContractLoadingCost?: boolean;
    /** @description See [VMConfig::gas_key_host_fns](crate::vm::Config::gas_key_host_fns). */
    gasKeyHostFns?: boolean;
    /** @description See [VMConfig::global_contract_host_fns](crate::vm::Config::global_contract_host_fns). */
    globalContractHostFns?: boolean;
    /**
     * Format: uint32
     * @description Gas cost of a growing memory by single page.
     */
    growMemCost?: number;
    /** @description Deprecated */
    implicitAccountCreation?: boolean;
    /** @description Describes limits for VM and Runtime.
     *
     *     TODO: Consider changing this to `VMLimitConfigView` to avoid dependency
     *     on runtime. */
    limitConfig?: LimitConfig;
    /**
     * Format: uint64
     * @description Base gas cost of a linear operation
     */
    linearOpBaseCost?: number;
    /**
     * Format: uint64
     * @description Unit gas cost of a linear operation
     */
    linearOpUnitCost?: number;
    /** @description See [VMConfig::ml_dsa_verify_host_fn](crate::vm::Config::ml_dsa_verify_host_fn). */
    mlDsaVerifyHostFn?: boolean;
    /** @description See [VMConfig::one_yocto_on_promise](crate::vm::Config::one_yocto_on_promise). */
    oneYoctoOnPromise?: boolean;
    /** @description See [VMConfig::p256_verify_host_fn](crate::vm::Config::p256_verify_host_fn). */
    p256VerifyHostFn?: boolean;
    /** @description See [VMConfig::reftypes_bulk_memory](crate::vm::Config::reftypes_bulk_memory). */
    reftypesBulkMemory?: boolean;
    /**
     * Format: uint32
     * @description Gas cost of a regular operation.
     */
    regularOpCost?: number;
    /** @description See [VMConfig::sha3_host_fns](crate::vm::Config::sha3_host_fns). */
    sha3HostFns?: boolean;
    /** @description See [VMConfig::storage_get_mode](crate::vm::Config::storage_get_mode). */
    storageGetMode?: StorageGetMode;
    /** @description See [VMConfig::vm_kind](crate::vm::Config::vm_kind). */
    vmKind?: VMKind;
    /** @description See [VMConfig::yield_with_id_host_fns](crate::vm::Config::yield_with_id_host_fns). */
    yieldWithIdHostFns?: boolean;
};
type VMKind = "Wasmer0" | "Wasmtime" | "Wasmer2" | "NearVm";
type WasmTrap = "Unreachable" | "IncorrectCallIndirectSignature" | "MemoryOutOfBounds" | "CallIndirectOOB" | "IllegalArithmetic" | "MisalignedAtomicAccess" | "IndirectCallToNull" | "StackOverflow" | "GenericTrap";
type WithdrawFromGasKeyAction = {
    /** @description Amount of NEAR to transfer from the gas key */
    amount: NearToken;
    /** @description The public key of the gas key to withdraw from */
    publicKey: PublicKey;
};
type WitnessConfigView = {
    /**
     * Format: uint
     * @description Maximum size of transactions contained inside ChunkStateWitness.
     *
     *     A witness contains transactions from both the previous chunk and the current one.
     *     This parameter limits the sum of sizes of transactions from both of those chunks.
     */
    combinedTransactionsSizeLimit?: number;
    /**
     * Format: uint64
     * @description Size limit for storage proof generated while executing receipts in a chunk.
     *     After this limit is reached we defer execution of any new receipts.
     */
    mainStorageProofSizeSoftLimit?: number;
    /**
     * Format: uint64
     * @description Soft size limit of storage proof used to validate new transactions in ChunkStateWitness.
     */
    newTransactionsValidationStateSizeSoftLimit?: number;
};
type JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsErrorResponse = Range_of_uint64[];
type JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorErrorResponse = ValidatorStakeView[];
type JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusErrorResponse = RpcHealthResponse | (null);
type RpcStateChangesInBlockByTypeRequestAccountChanges = ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "account_changes";
});
type RpcStateChangesInBlockByTypeRequestSingleAccessKeyChanges = ({
    blockId: BlockId;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
}) | ({
    finality: Finality;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    /** @enum {string} */
    changesType: "single_access_key_changes";
    keys: AccountWithPublicKey[];
});
type RpcStateChangesInBlockByTypeRequestAllAccessKeyChanges = ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "all_access_key_changes";
});
type RpcStateChangesInBlockByTypeRequestContractCodeChanges = ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "contract_code_changes";
});
type RpcStateChangesInBlockByTypeRequestDataChanges = ({
    blockId: BlockId;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
}) | ({
    finality: Finality;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountIds: AccountId[];
    /** @enum {string} */
    changesType: "data_changes";
    keyPrefixBase64: StoreKey;
});
type RpcQueryRequestViewAccount = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_account";
});
type RpcQueryRequestViewCode = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_code";
});
type RpcQueryRequestViewState = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    afterKeyBase64?: StoreKey | (null);
    includeProof?: boolean;
    /** Format: uint32 */
    limit?: number | null;
    prefixBase64: StoreKey;
    /** @enum {string} */
    requestType: "view_state";
});
type RpcQueryRequestViewAccessKey = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_access_key";
});
type RpcQueryRequestViewAccessKeyList = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    afterKey?: PublicKeyHandle | (null);
    /** Format: uint32 */
    limit?: number | null;
    /** @enum {string} */
    requestType: "view_access_key_list";
});
type RpcQueryRequestViewGasKeyNonces = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    publicKey: PublicKey;
    /** @enum {string} */
    requestType: "view_gas_key_nonces";
});
type RpcQueryRequestCallFunction = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    argsBase64: FunctionArgs;
    methodName: string;
    /** @enum {string} */
    requestType: "call_function";
});
type RpcQueryRequestViewGlobalContractCode = ({
    blockId: BlockId;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
}) | ({
    finality: Finality;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    codeHash: CryptoHash;
    /** @enum {string} */
    requestType: "view_global_contract_code";
});
type RpcQueryRequestViewGlobalContractCodeByAccountId = ({
    blockId: BlockId;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
}) | ({
    finality: Finality;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
}) | ({
    syncCheckpoint: SyncCheckpoint;
} & {
    accountId: AccountId;
    /** @enum {string} */
    requestType: "view_global_contract_code_by_account_id";
});
declare function DiscriminateRpcQueryResponse(obj: RpcQueryResponse): {
    AccountView?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & AccountView;
    ContractCodeView?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & ContractCodeView;
    ViewStateResult?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & ViewStateResult;
    CallResult?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & CallResult;
    AccessKeyView?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & AccessKeyView;
    AccessKeyList?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & AccessKeyList;
    GasKeyNoncesView?: {
        blockHash: CryptoHash;
        /** Format: uint64 */
        blockHeight: number;
    } & GasKeyNoncesView;
};
declare function DiscriminateRpcTransactionResponse(obj: RpcTransactionResponse): {
    FinalExecutionOutcomeWithReceiptView?: {
        finalExecutionStatus: TxExecutionStatus;
    } & FinalExecutionOutcomeWithReceiptView;
    FinalExecutionOutcomeView?: {
        finalExecutionStatus: TxExecutionStatus;
    } & FinalExecutionOutcomeView;
};

export { type AccessKey, type AccessKeyCreationConfigView, type AccessKeyInfoView, type AccessKeyList, type AccessKeyPermission, type AccessKeyPermissionView, type AccessKeyView, type AccountContractView, type AccountCreationConfigView, type AccountDataView, type AccountId, type AccountIdValidityRulesVersion, type AccountInfo, type AccountView, type AccountWithPublicKey, type ActionCreationConfigView, type ActionError, type ActionErrorKind, type ActionView, type ActionsValidationError, type AddKeyAction, type BandwidthRequest, type BandwidthRequestBitmap, type BandwidthRequests, type BandwidthRequestsV1, type BlockHeaderInnerLiteView, type BlockHeaderView, type BlockId, type BlockReference, type BlockStatusView, type CallResult, type CatchupStatusView, type ChunkDistributionNetworkConfig, type ChunkDistributionUris, type ChunkHash, type ChunkHeaderView, type CloudArchivalWriterConfig, type CompilationError, type CongestionControlConfigView, type CongestionInfoView, type ContractCodeView, type CostGasUsed, type CreateAccountAction, type CryptoHash, type CurrentEpochValidatorInfo, type DataReceiptCreationConfigView, type DataReceiverView, type DelegateAction, type DelegateActionV2, type DeleteAccountAction, type DeleteKeyAction, type DeployContractAction, type DeployGlobalContractAction, type DepositCostFailureReason, type DetailedDebugStatus, type DeterministicAccountStateInit, type DeterministicAccountStateInitV1, type DeterministicStateInitAction, type Direction, DiscriminateRpcQueryResponse, DiscriminateRpcTransactionResponse, type DumpConfig, type DurationAsStdSchemaProvider, type EpochId, type EpochSyncConfig, type ErrorWrapper_for_GenesisConfigError, type ErrorWrapper_for_RpcBlockError, type ErrorWrapper_for_RpcCallFunctionError, type ErrorWrapper_for_RpcChunkError, type ErrorWrapper_for_RpcClientConfigError, type ErrorWrapper_for_RpcGasPriceError, type ErrorWrapper_for_RpcLightClientNextBlockError, type ErrorWrapper_for_RpcLightClientProofError, type ErrorWrapper_for_RpcMaintenanceWindowsError, type ErrorWrapper_for_RpcNetworkInfoError, type ErrorWrapper_for_RpcProtocolConfigError, type ErrorWrapper_for_RpcQueryError, type ErrorWrapper_for_RpcReceiptError, type ErrorWrapper_for_RpcReceiptToTxError, type ErrorWrapper_for_RpcSplitStorageInfoError, type ErrorWrapper_for_RpcStateChangesError, type ErrorWrapper_for_RpcStatusError, type ErrorWrapper_for_RpcTransactionError, type ErrorWrapper_for_RpcValidatorError, type ErrorWrapper_for_RpcViewAccessKeyError, type ErrorWrapper_for_RpcViewAccessKeyListError, type ErrorWrapper_for_RpcViewAccountError, type ErrorWrapper_for_RpcViewCodeError, type ErrorWrapper_for_RpcViewStateError, type ExecutionMetadataView, type ExecutionOutcomeView, type ExecutionOutcomeWithIdView, type ExecutionStatusView, type ExtCostsConfigView, type ExternalStorageLocation, type Fee, type FinalExecutionOutcomeView, type FinalExecutionOutcomeWithReceiptView, type FinalExecutionStatus, type Finality, type FunctionArgs, type FunctionCallAction, type FunctionCallError, type FunctionCallPermission, type GCConfig, type GasKeyInfo, type GasKeyNoncesView, type GenesisConfig, type GenesisConfigError, type GenesisConfigRequest, type GlobalContractDeployMode, type GlobalContractIdentifier, type GlobalContractIdentifierView, type HostError, type InternalError, type InvalidAccessKeyError, type InvalidTxError, type JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsErrorResponse, type JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorErrorResponse, type JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusErrorResponse, type KnownProducerView, type LightClientBlockLiteView, type LimitConfig, type LogSummaryStyle, type MerklePathItem, type MethodResolveError, type MissingTrieValue, type MissingTrieValueContext, type MutableConfigValue, type NearGas, type NearToken, type NetworkInfoView, type NextEpochValidatorInfo, type NonDelegateAction, type NonceMode, type PeerId, type PeerInfoView, type PrepareError, type ProtocolVersionCheckConfig, type PublicKey, type PublicKeyHandle, type Range_of_uint64, type ReceiptEnumView, type ReceiptValidationError, type ReceiptView, type RpcBlockError, type RpcBlockRequest, type RpcBlockResponse, type RpcCallFunctionError, type RpcCallFunctionRequest, type RpcCallFunctionResponse, type RpcChunkError, type RpcChunkRequest, type RpcChunkResponse, type RpcClientConfigError, type RpcClientConfigRequest, type RpcClientConfigResponse, type RpcCongestionLevelRequest, type RpcCongestionLevelResponse, type RpcGasPriceError, type RpcGasPriceRequest, type RpcGasPriceResponse, type RpcHealthRequest, type RpcHealthResponse, type RpcKnownProducer, type RpcLightClientBlockProofRequest, type RpcLightClientBlockProofResponse, type RpcLightClientExecutionProofRequest, type RpcLightClientExecutionProofResponse, type RpcLightClientNextBlockError, type RpcLightClientNextBlockRequest, type RpcLightClientNextBlockResponse, type RpcLightClientProofError, type RpcMaintenanceWindowsError, type RpcMaintenanceWindowsRequest, type RpcNetworkInfoError, type RpcNetworkInfoRequest, type RpcNetworkInfoResponse, type RpcPeerInfo, type RpcProtocolConfigError, type RpcProtocolConfigRequest, type RpcProtocolConfigResponse, type RpcQueryError, type RpcQueryRequest, type RpcQueryRequestCallFunction, type RpcQueryRequestViewAccessKey, type RpcQueryRequestViewAccessKeyList, type RpcQueryRequestViewAccount, type RpcQueryRequestViewCode, type RpcQueryRequestViewGasKeyNonces, type RpcQueryRequestViewGlobalContractCode, type RpcQueryRequestViewGlobalContractCodeByAccountId, type RpcQueryRequestViewState, type RpcQueryResponse, type RpcReceiptError, type RpcReceiptRequest, type RpcReceiptResponse, type RpcReceiptToTxError, type RpcReceiptToTxRequest, type RpcReceiptToTxResponse, type RpcRequestValidationErrorKind, type RpcSendTransactionRequest, type RpcSplitStorageInfoError, type RpcSplitStorageInfoRequest, type RpcSplitStorageInfoResponse, type RpcStateChangesError, type RpcStateChangesInBlockByTypeRequest, type RpcStateChangesInBlockByTypeRequestAccountChanges, type RpcStateChangesInBlockByTypeRequestAllAccessKeyChanges, type RpcStateChangesInBlockByTypeRequestContractCodeChanges, type RpcStateChangesInBlockByTypeRequestDataChanges, type RpcStateChangesInBlockByTypeRequestSingleAccessKeyChanges, type RpcStateChangesInBlockByTypeResponse, type RpcStateChangesInBlockRequest, type RpcStateChangesInBlockResponse, type RpcStatusError, type RpcStatusRequest, type RpcStatusResponse, type RpcTransactionError, type RpcTransactionResponse, type RpcTransactionStatusRequest, type RpcValidatorError, type RpcValidatorRequest, type RpcValidatorResponse, type RpcValidatorsOrderedRequest, type RpcViewAccessKeyError, type RpcViewAccessKeyListError, type RpcViewAccessKeyListRequest, type RpcViewAccessKeyListResponse, type RpcViewAccessKeyRequest, type RpcViewAccessKeyResponse, type RpcViewAccountError, type RpcViewAccountRequest, type RpcViewAccountResponse, type RpcViewCodeError, type RpcViewCodeRequest, type RpcViewCodeResponse, type RpcViewStateError, type RpcViewStateRequest, type RpcViewStateResponse, type RuntimeConfigView, type RuntimeFeesConfigView, type ShardId, type ShardLayout, type ShardLayoutV0, type ShardLayoutV1, type ShardLayoutV2, type ShardLayoutV3, type ShardUId, type Signature, type SignedDelegateAction, type SignedTransaction, type SignedTransactionView, type SlashedValidator, type SpiceChunkEndorsementStats, type StakeAction, type StateChangeCauseView, type StateChangeKindView, type StateChangeWithCauseView, type StateItem, type StateSyncConfig, type StatusSyncInfo, type StorageError, type StorageGetMode, type StorageUsageConfigView, type StoreKey, type StoreValue, type SyncCheckpoint, type SyncConcurrency, type SyncConfig, type Tier1ProxyView, type TimeoutErrorCause, type TrackedShardsConfig, type TransactionNonce, type TransferAction, type TransferToGasKeyAction, type TrieSplit, type TxExecutionError, type TxExecutionStatus, type UseGlobalContractAction, type VMConfigView, type VMKind, type ValidatorInfo, type ValidatorKickoutReason, type ValidatorKickoutView, type ValidatorStakeView, type ValidatorStakeViewV1, type Version, type VersionedDelegateActionPayload, type VersionedSignedDelegateAction, type ViewStateResult, type WasmTrap, type WithdrawFromGasKeyAction, type WitnessConfigView };