near-jsonrpc-client 1.0.4__py3-none-any.whl → 1.0.13__py3-none-any.whl

near_jsonrpc_client/__init__.py

@@ -0,0 +1,27 @@
+from .client import NearClientAsync, NearClientSync
+from .transport import HttpTransportAsync, HttpTransportSync
+from .errors import (
+    ClientError,
+    TransportError,
+    HttpError,
+    RpcError,
+    RequestTimeoutError
+)
+
+__all__ = [
+    # Main clients
+    "NearClientAsync",
+    "NearClientSync",
+
+    # Transport
+
+    "HttpTransportAsync",
+    "HttpTransportSync",
+
+    # Errors
+    "ClientError",
+    "TransportError",
+    "HttpError",
+    "RpcError",
+    "RequestTimeoutError"
+]

{client → near_jsonrpc_client}/api_methods_async.py

@@ -8,443 +8,443 @@ that exposes `_call(...)`.
 
 from .base_client import NearBaseClientAsync
 
-import models
+import near_jsonrpc_models
 
 
 class APIMixinAsync:
 
 
-    async def experimental_call_function(self: NearBaseClientAsync, *, params: models.RpcCallFunctionRequest) -> models.RpcCallFunctionResponse:
+    async def experimental_call_function(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcCallFunctionRequest) -> near_jsonrpc_models.RpcCallFunctionResponse:
         """
         Calls a view function on a contract and returns the result.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalCallFunction,
-            response_model=models.JsonRpcResponseForRpcCallFunctionResponseAndRpcCallFunctionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalCallFunction,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcCallFunctionResponseAndRpcCallFunctionError,
             params=params,
         )
 
-    async def experimental_changes(self: NearBaseClientAsync, *, params: models.RpcStateChangesInBlockByTypeRequest) -> models.RpcStateChangesInBlockResponse:
+    async def experimental_changes(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcStateChangesInBlockByTypeRequest) -> near_jsonrpc_models.RpcStateChangesInBlockResponse:
         """
         [Deprecated] Returns changes for a given account, contract or contract code for given block height or hash. Consider using changes instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalChanges,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalChanges,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
             params=params,
         )
 
-    async def experimental_changes_in_block(self: NearBaseClientAsync, *, params: models.RpcStateChangesInBlockRequest) -> models.RpcStateChangesInBlockByTypeResponse:
+    async def experimental_changes_in_block(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcStateChangesInBlockRequest) -> near_jsonrpc_models.RpcStateChangesInBlockByTypeResponse:
         """
         [Deprecated] Returns changes in block for given block height or hash over all transactions for all the types. Includes changes like account_touched, access_key_touched, data_touched, contract_code_touched. Consider using block_effects instead
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalChangesInBlock,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalChangesInBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
             params=params,
         )
 
-    async def experimental_congestion_level(self: NearBaseClientAsync, *, params: models.RpcCongestionLevelRequest) -> models.RpcCongestionLevelResponse:
+    async def experimental_congestion_level(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcCongestionLevelRequest) -> near_jsonrpc_models.RpcCongestionLevelResponse:
         """
         Queries the congestion level of a shard. More info about congestion [here](https://near.github.io/nearcore/architecture/how/receipt-congestion.html?highlight=congestion#receipt-congestion)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalCongestionLevel,
-            response_model=models.JsonRpcResponseForRpcCongestionLevelResponseAndRpcChunkError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalCongestionLevel,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcCongestionLevelResponseAndRpcChunkError,
             params=params,
         )
 
-    async def experimental_genesis_config(self: NearBaseClientAsync) -> models.GenesisConfig:
+    async def experimental_genesis_config(self: NearBaseClientAsync) -> near_jsonrpc_models.GenesisConfig:
         """
         [Deprecated] Get initial state and parameters for the genesis block. Consider genesis_config instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.GenesisConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.GenesisConfigRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalGenesisConfig,
-            response_model=models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalGenesisConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
             params=params,
         )
 
-    async def experimental_light_client_block_proof(self: NearBaseClientAsync, *, params: models.RpcLightClientBlockProofRequest) -> models.RpcLightClientBlockProofResponse:
+    async def experimental_light_client_block_proof(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcLightClientBlockProofRequest) -> near_jsonrpc_models.RpcLightClientBlockProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalLightClientBlockProof,
-            response_model=models.JsonRpcResponseForRpcLightClientBlockProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalLightClientBlockProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientBlockProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    async def experimental_light_client_proof(self: NearBaseClientAsync, *, params: models.RpcLightClientExecutionProofRequest) -> models.RpcLightClientExecutionProofResponse:
+    async def experimental_light_client_proof(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcLightClientExecutionProofRequest) -> near_jsonrpc_models.RpcLightClientExecutionProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalLightClientProof,
-            response_model=models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalLightClientProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    async def experimental_maintenance_windows(self: NearBaseClientAsync, *, params: models.RpcMaintenanceWindowsRequest) -> models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
+    async def experimental_maintenance_windows(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcMaintenanceWindowsRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
         """
         [Deprecated] Returns the future windows for maintenance in current epoch for the specified account. In the maintenance windows, the node will not be block producer or chunk producer. Consider using maintenance_windows instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalMaintenanceWindows,
-            response_model=models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalMaintenanceWindows,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
             params=params,
         )
 
-    async def experimental_protocol_config(self: NearBaseClientAsync, *, params: models.RpcProtocolConfigRequest) -> models.RpcProtocolConfigResponse:
+    async def experimental_protocol_config(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcProtocolConfigRequest) -> near_jsonrpc_models.RpcProtocolConfigResponse:
         """
         A configuration that defines the protocol-level parameters such as gas/storage costs, limits, feature flags, other settings
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalProtocolConfig,
-            response_model=models.JsonRpcResponseForRpcProtocolConfigResponseAndRpcProtocolConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalProtocolConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcProtocolConfigResponseAndRpcProtocolConfigError,
             params=params,
         )
 
-    async def experimental_receipt(self: NearBaseClientAsync, *, params: models.RpcReceiptRequest) -> models.RpcReceiptResponse:
+    async def experimental_receipt(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcReceiptRequest) -> near_jsonrpc_models.RpcReceiptResponse:
         """
         Fetches a receipt by its ID (as is, without a status or execution outcome)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalReceipt,
-            response_model=models.JsonRpcResponseForRpcReceiptResponseAndRpcReceiptError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalReceipt,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcReceiptResponseAndRpcReceiptError,
             params=params,
         )
 
-    async def experimental_split_storage_info(self: NearBaseClientAsync, *, params: models.RpcSplitStorageInfoRequest) -> models.RpcSplitStorageInfoResponse:
+    async def experimental_split_storage_info(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcSplitStorageInfoRequest) -> near_jsonrpc_models.RpcSplitStorageInfoResponse:
         """
         Contains the split storage information. More info on split storage [here](https://near-nodes.io/archival/split-storage-archival)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalSplitStorageInfo,
-            response_model=models.JsonRpcResponseForRpcSplitStorageInfoResponseAndRpcSplitStorageInfoError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalSplitStorageInfo,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcSplitStorageInfoResponseAndRpcSplitStorageInfoError,
             params=params,
         )
 
-    async def experimental_tx_status(self: NearBaseClientAsync, *, params: models.RpcTransactionStatusRequest) -> models.RpcTransactionResponse:
+    async def experimental_tx_status(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcTransactionStatusRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Queries status of a transaction by hash, returning the final transaction result and details of all receipts.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalTxStatus,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalTxStatus,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    async def experimental_validators_ordered(self: NearBaseClientAsync, *, params: models.RpcValidatorsOrderedRequest) -> models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError:
+    async def experimental_validators_ordered(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcValidatorsOrderedRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError:
         """
         Returns the current epoch validators ordered in the block producer order with repetition. This endpoint is solely used for bridge currently and is not intended for other external use cases.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalValidatorsOrdered,
-            response_model=models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalValidatorsOrdered,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError,
             params=params,
         )
 
-    async def experimental_view_access_key(self: NearBaseClientAsync, *, params: models.RpcViewAccessKeyRequest) -> models.RpcViewAccessKeyResponse:
+    async def experimental_view_access_key(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewAccessKeyRequest) -> near_jsonrpc_models.RpcViewAccessKeyResponse:
         """
         Returns information about a single access key for given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccessKey,
-            response_model=models.JsonRpcResponseForRpcViewAccessKeyResponseAndRpcViewAccessKeyError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccessKey,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccessKeyResponseAndRpcViewAccessKeyError,
             params=params,
         )
 
-    async def experimental_view_access_key_list(self: NearBaseClientAsync, *, params: models.RpcViewAccessKeyListRequest) -> models.RpcViewAccessKeyListResponse:
+    async def experimental_view_access_key_list(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewAccessKeyListRequest) -> near_jsonrpc_models.RpcViewAccessKeyListResponse:
         """
         Returns all access keys for a given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccessKeyList,
-            response_model=models.JsonRpcResponseForRpcViewAccessKeyListResponseAndRpcViewAccessKeyListError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccessKeyList,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccessKeyListResponseAndRpcViewAccessKeyListError,
             params=params,
         )
 
-    async def experimental_view_account(self: NearBaseClientAsync, *, params: models.RpcViewAccountRequest) -> models.RpcViewAccountResponse:
+    async def experimental_view_account(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewAccountRequest) -> near_jsonrpc_models.RpcViewAccountResponse:
         """
         Returns information about an account for given account_id.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccount,
-            response_model=models.JsonRpcResponseForRpcViewAccountResponseAndRpcViewAccountError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccount,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccountResponseAndRpcViewAccountError,
             params=params,
         )
 
-    async def experimental_view_code(self: NearBaseClientAsync, *, params: models.RpcViewCodeRequest) -> models.RpcViewCodeResponse:
+    async def experimental_view_code(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewCodeRequest) -> near_jsonrpc_models.RpcViewCodeResponse:
         """
         Returns the contract code (Wasm binary) deployed to the account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewCode,
-            response_model=models.JsonRpcResponseForRpcViewCodeResponseAndRpcViewCodeError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewCode,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewCodeResponseAndRpcViewCodeError,
             params=params,
         )
 
-    async def experimental_view_gas_key(self: NearBaseClientAsync, *, params: models.RpcViewGasKeyRequest) -> models.RpcViewGasKeyResponse:
+    async def experimental_view_gas_key(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewGasKeyRequest) -> near_jsonrpc_models.RpcViewGasKeyResponse:
         """
         Returns information about a single gas key for given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewGasKey,
-            response_model=models.JsonRpcResponseForRpcViewGasKeyResponseAndRpcViewGasKeyError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewGasKey,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewGasKeyResponseAndRpcViewGasKeyError,
             params=params,
         )
 
-    async def experimental_view_gas_key_list(self: NearBaseClientAsync, *, params: models.RpcViewGasKeyListRequest) -> models.RpcViewGasKeyListResponse:
+    async def experimental_view_gas_key_list(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewGasKeyListRequest) -> near_jsonrpc_models.RpcViewGasKeyListResponse:
         """
         Returns all gas keys for a given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewGasKeyList,
-            response_model=models.JsonRpcResponseForRpcViewGasKeyListResponseAndRpcViewGasKeyListError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewGasKeyList,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewGasKeyListResponseAndRpcViewGasKeyListError,
             params=params,
         )
 
-    async def experimental_view_state(self: NearBaseClientAsync, *, params: models.RpcViewStateRequest) -> models.RpcViewStateResponse:
+    async def experimental_view_state(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcViewStateRequest) -> near_jsonrpc_models.RpcViewStateResponse:
         """
         Returns the state (key-value pairs) of a contract based on the key prefix.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewState,
-            response_model=models.JsonRpcResponseForRpcViewStateResponseAndRpcViewStateError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewState,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewStateResponseAndRpcViewStateError,
             params=params,
         )
 
-    async def block(self: NearBaseClientAsync, *, params: models.RpcBlockRequest) -> models.RpcBlockResponse:
+    async def block(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcBlockRequest) -> near_jsonrpc_models.RpcBlockResponse:
         """
         Returns block details for given height or hash
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForBlock,
-            response_model=models.JsonRpcResponseForRpcBlockResponseAndRpcBlockError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcBlockResponseAndRpcBlockError,
             params=params,
         )
 
-    async def block_effects(self: NearBaseClientAsync, *, params: models.RpcStateChangesInBlockRequest) -> models.RpcStateChangesInBlockByTypeResponse:
+    async def block_effects(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcStateChangesInBlockRequest) -> near_jsonrpc_models.RpcStateChangesInBlockByTypeResponse:
         """
         Returns changes in block for given block height or hash over all transactions for all the types. Includes changes like account_touched, access_key_touched, data_touched, contract_code_touched.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForBlockEffects,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBlockEffects,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
             params=params,
         )
 
-    async def broadcast_tx_async(self: NearBaseClientAsync, *, params: models.RpcSendTransactionRequest) -> models.CryptoHash:
+    async def broadcast_tx_async(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.CryptoHash:
         """
         [Deprecated] Sends a transaction and immediately returns transaction hash. Consider using send_tx instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForBroadcastTxAsync,
-            response_model=models.JsonRpcResponseForCryptoHashAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBroadcastTxAsync,
+            response_model=near_jsonrpc_models.JsonRpcResponseForCryptoHashAndRpcTransactionError,
             params=params,
         )
 
-    async def broadcast_tx_commit(self: NearBaseClientAsync, *, params: models.RpcSendTransactionRequest) -> models.RpcTransactionResponse:
+    async def broadcast_tx_commit(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         [Deprecated] Sends a transaction and waits until transaction is fully complete. (Has a 10 second timeout). Consider using send_tx instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForBroadcastTxCommit,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBroadcastTxCommit,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    async def changes(self: NearBaseClientAsync, *, params: models.RpcStateChangesInBlockByTypeRequest) -> models.RpcStateChangesInBlockResponse:
+    async def changes(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcStateChangesInBlockByTypeRequest) -> near_jsonrpc_models.RpcStateChangesInBlockResponse:
         """
         Returns changes for a given account, contract or contract code for given block height or hash.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForChanges,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForChanges,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
             params=params,
         )
 
-    async def chunk(self: NearBaseClientAsync, *, params: models.RpcChunkRequest) -> models.RpcChunkResponse:
+    async def chunk(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcChunkRequest) -> near_jsonrpc_models.RpcChunkResponse:
         """
         Returns details of a specific chunk. You can run a block details query to get a valid chunk hash.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForChunk,
-            response_model=models.JsonRpcResponseForRpcChunkResponseAndRpcChunkError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForChunk,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcChunkResponseAndRpcChunkError,
             params=params,
         )
 
-    async def client_config(self: NearBaseClientAsync) -> models.RpcClientConfigResponse:
+    async def client_config(self: NearBaseClientAsync) -> near_jsonrpc_models.RpcClientConfigResponse:
         """
         Queries client node configuration
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcClientConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcClientConfigRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForClientConfig,
-            response_model=models.JsonRpcResponseForRpcClientConfigResponseAndRpcClientConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForClientConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcClientConfigResponseAndRpcClientConfigError,
             params=params,
         )
 
-    async def gas_price(self: NearBaseClientAsync, *, params: models.RpcGasPriceRequest) -> models.RpcGasPriceResponse:
+    async def gas_price(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcGasPriceRequest) -> near_jsonrpc_models.RpcGasPriceResponse:
         """
         Returns gas price for a specific block_height or block_hash. Using [null] will return the most recent block's gas price.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForGasPrice,
-            response_model=models.JsonRpcResponseForRpcGasPriceResponseAndRpcGasPriceError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForGasPrice,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcGasPriceResponseAndRpcGasPriceError,
             params=params,
         )
 
-    async def genesis_config(self: NearBaseClientAsync) -> models.GenesisConfig:
+    async def genesis_config(self: NearBaseClientAsync) -> near_jsonrpc_models.GenesisConfig:
         """
         Get initial state and parameters for the genesis block
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.GenesisConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.GenesisConfigRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForGenesisConfig,
-            response_model=models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForGenesisConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
             params=params,
         )
 
-    async def health(self: NearBaseClientAsync) -> models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError:
+    async def health(self: NearBaseClientAsync) -> near_jsonrpc_models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError:
         """
         Returns the current health status of the RPC node the client connects to.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcHealthRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcHealthRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForHealth,
-            response_model=models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForHealth,
+            response_model=near_jsonrpc_models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError,
             params=params,
         )
 
-    async def light_client_proof(self: NearBaseClientAsync, *, params: models.RpcLightClientExecutionProofRequest) -> models.RpcLightClientExecutionProofResponse:
+    async def light_client_proof(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcLightClientExecutionProofRequest) -> near_jsonrpc_models.RpcLightClientExecutionProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForLightClientProof,
-            response_model=models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForLightClientProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    async def maintenance_windows(self: NearBaseClientAsync, *, params: models.RpcMaintenanceWindowsRequest) -> models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
+    async def maintenance_windows(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcMaintenanceWindowsRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
         """
         Returns the future windows for maintenance in current epoch for the specified account. In the maintenance windows, the node will not be block producer or chunk producer.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForMaintenanceWindows,
-            response_model=models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForMaintenanceWindows,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
             params=params,
         )
 
-    async def network_info(self: NearBaseClientAsync) -> models.RpcNetworkInfoResponse:
+    async def network_info(self: NearBaseClientAsync) -> near_jsonrpc_models.RpcNetworkInfoResponse:
         """
         Queries the current state of node network connections. This includes information about active peers, transmitted data, known producers, etc.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcNetworkInfoRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcNetworkInfoRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForNetworkInfo,
-            response_model=models.JsonRpcResponseForRpcNetworkInfoResponseAndRpcNetworkInfoError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForNetworkInfo,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcNetworkInfoResponseAndRpcNetworkInfoError,
             params=params,
         )
 
-    async def next_light_client_block(self: NearBaseClientAsync, *, params: models.RpcLightClientNextBlockRequest) -> models.RpcLightClientNextBlockResponse:
+    async def next_light_client_block(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcLightClientNextBlockRequest) -> near_jsonrpc_models.RpcLightClientNextBlockResponse:
         """
         Returns the next light client block.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForNextLightClientBlock,
-            response_model=models.JsonRpcResponseForRpcLightClientNextBlockResponseAndRpcLightClientNextBlockError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForNextLightClientBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientNextBlockResponseAndRpcLightClientNextBlockError,
             params=params,
         )
 
-    async def query(self: NearBaseClientAsync, *, params: models.RpcQueryRequest) -> models.RpcQueryResponse:
+    async def query(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcQueryRequest) -> near_jsonrpc_models.RpcQueryResponse:
         """
         This module allows you to make generic requests to the network.  The `RpcQueryRequest` struct takes in a [`BlockReference`](https://docs.rs/near-primitives/0.12.0/near_primitives/types/enum.BlockReference.html) and a [`QueryRequest`](https://docs.rs/near-primitives/0.12.0/near_primitives/views/enum.QueryRequest.html).  The `BlockReference` enum allows you to specify a block by `Finality`, `BlockId` or `SyncCheckpoint`.  The `QueryRequest` enum provides multiple variants for performing the following actions:  - View an account's details  - View a contract's code  - View the state of an account  - View the `AccessKey` of an account  - View the `AccessKeyList` of an account  - Call a function in a contract deployed on the network.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForQuery,
-            response_model=models.JsonRpcResponseForRpcQueryResponseAndRpcQueryError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForQuery,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcQueryResponseAndRpcQueryError,
             params=params,
         )
 
-    async def send_tx(self: NearBaseClientAsync, *, params: models.RpcSendTransactionRequest) -> models.RpcTransactionResponse:
+    async def send_tx(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Sends transaction. Returns the guaranteed execution status and the results the blockchain can provide at the moment.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForSendTx,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForSendTx,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    async def status(self: NearBaseClientAsync) -> models.RpcStatusResponse:
+    async def status(self: NearBaseClientAsync) -> near_jsonrpc_models.RpcStatusResponse:
         """
         Requests the status of the connected RPC node. This includes information about sync status, nearcore node version, protocol version, the current set of validators, etc.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcStatusRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcStatusRequest.model_validate(None)
         return await self._call(
-            request_model=models.JsonRpcRequestForStatus,
-            response_model=models.JsonRpcResponseForRpcStatusResponseAndRpcStatusError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForStatus,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStatusResponseAndRpcStatusError,
             params=params,
         )
 
-    async def tx(self: NearBaseClientAsync, *, params: models.RpcTransactionStatusRequest) -> models.RpcTransactionResponse:
+    async def tx(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcTransactionStatusRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Queries status of a transaction by hash and returns the final transaction result.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForTx,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForTx,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    async def validators(self: NearBaseClientAsync, *, params: models.RpcValidatorRequest) -> models.RpcValidatorResponse:
+    async def validators(self: NearBaseClientAsync, *, params: near_jsonrpc_models.RpcValidatorRequest) -> near_jsonrpc_models.RpcValidatorResponse:
         """
         Queries active validators on the network. Returns details and the state of validation on the blockchain.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return await self._call(
-            request_model=models.JsonRpcRequestForValidators,
-            response_model=models.JsonRpcResponseForRpcValidatorResponseAndRpcValidatorError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForValidators,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcValidatorResponseAndRpcValidatorError,
             params=params,
         )