@psalomo/jsonrpc-client 1.2.0 → 1.3.1

package/dist/browser-standalone.js

@@ -1,3 +1,4 @@
+// JSON-RPC client with static function architecture (configuration only)
 // Case conversion utilities
 function camelToSnake(str) {
     return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
@@ -66,7 +67,6 @@ class NearRpcClient {
     headers;
     timeout;
     retries;
-    validation;
     constructor(config) {
         if (typeof config === 'string') {
             this.endpoint = config;
@@ -79,9 +79,6 @@ class NearRpcClient {
             this.headers = config.headers || {};
             this.timeout = config.timeout || 30000;
             this.retries = config.retries || 3;
-            if (config.validation) {
-                this.validation = config.validation;
-            }
         }
     }
     /**
@@ -89,22 +86,6 @@ class NearRpcClient {
      * This is used internally by the standalone RPC functions
      */
     async makeRequest(method, params) {
-        // Create request with original camelCase params for validation
-        const requestForValidation = {
-            jsonrpc: '2.0',
-            id: REQUEST_ID,
-            method,
-            params: params !== undefined ? params : null,
-        };
-        // Validate request if validation is enabled (before snake_case conversion)
-        if (this.validation) {
-            if ('validateMethodRequest' in this.validation) {
-                this.validation.validateMethodRequest(method, requestForValidation);
-            }
-            else {
-                this.validation.validateRequest(requestForValidation);
-            }
-        }
         // Convert camelCase params to snake_case for the RPC call
         // Also convert undefined to null for methods that expect null params
         const snakeCaseParams = params !== undefined ? convertKeysToSnakeCase(params) : null;
@@ -148,10 +129,6 @@ class NearRpcClient {
                 if (!response.ok) {
                     throw new JsonRpcNetworkError(`HTTP error! status: ${response.status}`, undefined, jsonResponse);
                 }
-                // Validate basic JSON-RPC response structure
-                if (this.validation) {
-                    this.validation.validateResponse(jsonResponse);
-                }
                 // Convert snake_case response back to camelCase
                 const camelCaseResult = jsonResponse.result
                     ? convertKeysToCamelCase(jsonResponse.result)
@@ -165,15 +142,6 @@ class NearRpcClient {
                     throw new JsonRpcClientError(`RPC Error: ${errorMessage}`, -32000, // Generic RPC error code
                     camelCaseResult);
                 }
-                // Validate method-specific response structure after camelCase conversion
-                if (this.validation && 'validateMethodResponse' in this.validation) {
-                    // Create a camelCase version of the response for validation
-                    const camelCaseResponse = {
-                        ...jsonResponse,
-                        result: camelCaseResult,
-                    };
-                    this.validation.validateMethodResponse(method, camelCaseResponse);
-                }
                 return camelCaseResult;
             }
             catch (error) {
@@ -201,11 +169,6 @@ class NearRpcClient {
             headers: config.headers ?? this.headers,
             timeout: config.timeout ?? this.timeout,
             retries: config.retries ?? this.retries,
-            ...(config.validation !== undefined
-                ? { validation: config.validation }
-                : this.validation !== undefined
-                    ? { validation: this.validation }
-                    : {}),
         });
     }
 }
@@ -2639,508 +2602,6 @@ var InvalidTxErrorSchema = () => union([
     })
   })
 ]);
-var JsonRpcRequestFor_EXPERIMENTALChangesSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_changes"]),
-  params: _lazy(() => RpcStateChangesInBlockByTypeRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALChangesInBlockSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_changes_in_block"]),
-  params: _lazy(() => RpcStateChangesInBlockRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALCongestionLevelSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_congestion_level"]),
-  params: _lazy(() => RpcCongestionLevelRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALGenesisConfigSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_genesis_config"]),
-  params: _lazy(() => GenesisConfigRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALLightClientBlockProofSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_light_client_block_proof"]),
-  params: _lazy(() => RpcLightClientBlockProofRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALLightClientProofSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_light_client_proof"]),
-  params: _lazy(() => RpcLightClientExecutionProofRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALMaintenanceWindowsSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_maintenance_windows"]),
-  params: _lazy(() => RpcMaintenanceWindowsRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALProtocolConfigSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_protocol_config"]),
-  params: _lazy(() => RpcProtocolConfigRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALReceiptSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_receipt"]),
-  params: _lazy(() => RpcReceiptRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALSplitStorageInfoSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_split_storage_info"]),
-  params: _lazy(() => RpcSplitStorageInfoRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALTxStatusSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_tx_status"]),
-  params: _lazy(() => RpcTransactionStatusRequestSchema())
-});
-var JsonRpcRequestFor_EXPERIMENTALValidatorsOrderedSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["EXPERIMENTAL_validators_ordered"]),
-  params: _lazy(() => RpcValidatorsOrderedRequestSchema())
-});
-var JsonRpcRequestForBlockSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["block"]),
-  params: _lazy(() => RpcBlockRequestSchema())
-});
-var JsonRpcRequestForBlockEffectsSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["block_effects"]),
-  params: _lazy(() => RpcStateChangesInBlockRequestSchema())
-});
-var JsonRpcRequestForBroadcastTxAsyncSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["broadcast_tx_async"]),
-  params: _lazy(() => RpcSendTransactionRequestSchema())
-});
-var JsonRpcRequestForBroadcastTxCommitSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["broadcast_tx_commit"]),
-  params: _lazy(() => RpcSendTransactionRequestSchema())
-});
-var JsonRpcRequestForChangesSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["changes"]),
-  params: _lazy(() => RpcStateChangesInBlockByTypeRequestSchema())
-});
-var JsonRpcRequestForChunkSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["chunk"]),
-  params: _lazy(() => RpcChunkRequestSchema())
-});
-var JsonRpcRequestForClientConfigSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["client_config"]),
-  params: _lazy(() => RpcClientConfigRequestSchema())
-});
-var JsonRpcRequestForGasPriceSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["gas_price"]),
-  params: _lazy(() => RpcGasPriceRequestSchema())
-});
-var JsonRpcRequestForHealthSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["health"]),
-  params: _lazy(() => RpcHealthRequestSchema())
-});
-var JsonRpcRequestForLightClientProofSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["light_client_proof"]),
-  params: _lazy(() => RpcLightClientExecutionProofRequestSchema())
-});
-var JsonRpcRequestForMaintenanceWindowsSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["maintenance_windows"]),
-  params: _lazy(() => RpcMaintenanceWindowsRequestSchema())
-});
-var JsonRpcRequestForNetworkInfoSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["network_info"]),
-  params: _lazy(() => RpcNetworkInfoRequestSchema())
-});
-var JsonRpcRequestForNextLightClientBlockSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["next_light_client_block"]),
-  params: _lazy(() => RpcLightClientNextBlockRequestSchema())
-});
-var JsonRpcRequestForQuerySchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["query"]),
-  params: _lazy(() => RpcQueryRequestSchema())
-});
-var JsonRpcRequestForSendTxSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["send_tx"]),
-  params: _lazy(() => RpcSendTransactionRequestSchema())
-});
-var JsonRpcRequestForStatusSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["status"]),
-  params: _lazy(() => RpcStatusRequestSchema())
-});
-var JsonRpcRequestForTxSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["tx"]),
-  params: _lazy(() => RpcTransactionStatusRequestSchema())
-});
-var JsonRpcRequestForValidatorsSchema = () => object({
-  id: string(),
-  jsonrpc: string(),
-  method: _enum(["validators"]),
-  params: _lazy(() => RpcValidatorRequestSchema())
-});
-var JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: array(_lazy(() => RangeOfUint64Schema()))
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: array(_lazy(() => ValidatorStakeViewSchema()))
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => CryptoHashSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => GenesisConfigSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: union([_lazy(() => RpcHealthResponseSchema()), _null()])
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcBlockResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcChunkResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcClientConfigResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcCongestionLevelResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcGasPriceResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcLightClientBlockProofResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcLightClientExecutionProofResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcLightClientNextBlockResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcNetworkInfoResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcProtocolConfigResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcQueryResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcReceiptResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcSplitStorageInfoResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcStateChangesInBlockByTypeResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcStateChangesInBlockResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcStatusResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcTransactionResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
-var JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema = () => intersection(
-  union([
-    object({
-      result: _lazy(() => RpcValidatorResponseSchema())
-    }),
-    object({
-      error: _lazy(() => RpcErrorSchema())
-    })
-  ]),
-  object({
-    id: string(),
-    jsonrpc: string()
-  })
-);
 var KnownProducerViewSchema = () => object({
   accountId: _lazy(() => AccountIdSchema()),
   nextHops: optional(
@@ -3257,10 +2718,6 @@ var PrepareErrorSchema = () => union([
   _enum(["TooManyLocals"])
 ]);
 var PublicKeySchema = () => string();
-var RangeOfUint64Schema = () => object({
-  end: number(),
-  start: number()
-});
 var ReceiptEnumViewSchema = () => union([
   object({
     Action: object({
@@ -3455,29 +2912,6 @@ var RpcCongestionLevelRequestSchema = () => union([
 var RpcCongestionLevelResponseSchema = () => object({
   congestionLevel: number()
 });
-var RpcErrorSchema = () => intersection(
-  union([
-    object({
-      cause: _lazy(() => RpcRequestValidationErrorKindSchema()),
-      name: _enum(["REQUEST_VALIDATION_ERROR"])
-    }),
-    object({
-      cause: unknown(),
-      name: _enum(["HANDLER_ERROR"])
-    }),
-    object({
-      cause: unknown(),
-      name: _enum(["INTERNAL_ERROR"])
-    })
-  ]),
-  object({
-    cause: optional(unknown()),
-    code: number(),
-    data: optional(unknown()),
-    message: string(),
-    name: optional(unknown())
-  })
-);
 var RpcGasPriceRequestSchema = () => object({
   blockId: optional(union([_lazy(() => BlockIdSchema()), _null()]))
 });
@@ -3854,20 +3288,6 @@ var RpcReceiptResponseSchema = () => object({
   receiptId: _lazy(() => CryptoHashSchema()),
   receiverId: _lazy(() => AccountIdSchema())
 });
-var RpcRequestValidationErrorKindSchema = () => union([
-  object({
-    info: object({
-      methodName: string()
-    }),
-    name: _enum(["METHOD_NOT_FOUND"])
-  }),
-  object({
-    info: object({
-      errorMessage: string()
-    }),
-    name: _enum(["PARSE_ERROR"])
-  })
-]);
 var RpcSendTransactionRequestSchema = () => object({
   signedTxBase64: _lazy(() => SignedTransactionSchema()),
   waitUntil: optional(_lazy(() => TxExecutionStatusSchema()))
@@ -4623,216 +4043,6 @@ var WitnessConfigViewSchema = () => object({
   mainStorageProofSizeSoftLimit: number(),
   newTransactionsValidationStateSizeSoftLimit: number()
 });
-var EXPERIMENTALChangesRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALChangesSchema());
-var EXPERIMENTALChangesResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALChangesInBlockRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALChangesInBlockSchema());
-var EXPERIMENTALChangesInBlockResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALCongestionLevelRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALCongestionLevelSchema());
-var EXPERIMENTALCongestionLevelResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALGenesisConfigRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALGenesisConfigSchema());
-var EXPERIMENTALGenesisConfigResponseSchema = () => _lazy(() => JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema());
-var EXPERIMENTALLightClientBlockProofRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALLightClientBlockProofSchema());
-var EXPERIMENTALLightClientBlockProofResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALLightClientProofRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALLightClientProofSchema());
-var EXPERIMENTALLightClientProofResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALMaintenanceWindowsRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALMaintenanceWindowsSchema());
-var EXPERIMENTALMaintenanceWindowsResponseSchema = () => _lazy(() => JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema());
-var EXPERIMENTALProtocolConfigRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALProtocolConfigSchema());
-var EXPERIMENTALProtocolConfigResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALReceiptRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALReceiptSchema());
-var EXPERIMENTALReceiptResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema());
-var EXPERIMENTALSplitStorageInfoRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALSplitStorageInfoSchema());
-var EXPERIMENTALSplitStorageInfoResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema()
-);
-var EXPERIMENTALTxStatusRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALTxStatusSchema());
-var EXPERIMENTALTxStatusResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema());
-var EXPERIMENTALValidatorsOrderedRequestSchema = () => _lazy(() => JsonRpcRequestFor_EXPERIMENTALValidatorsOrderedSchema());
-var EXPERIMENTALValidatorsOrderedResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema()
-);
-var BlockRequestSchema = () => _lazy(() => JsonRpcRequestForBlockSchema());
-var BlockResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema());
-var BlockEffectsRequestSchema = () => _lazy(() => JsonRpcRequestForBlockEffectsSchema());
-var BlockEffectsResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema()
-);
-var BroadcastTxAsyncRequestSchema = () => _lazy(() => JsonRpcRequestForBroadcastTxAsyncSchema());
-var BroadcastTxAsyncResponseSchema = () => _lazy(() => JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema());
-var BroadcastTxCommitRequestSchema = () => _lazy(() => JsonRpcRequestForBroadcastTxCommitSchema());
-var BroadcastTxCommitResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema());
-var ChangesRequestSchema = () => _lazy(() => JsonRpcRequestForChangesSchema());
-var ChangesResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema()
-);
-var ChunkRequestSchema = () => _lazy(() => JsonRpcRequestForChunkSchema());
-var ChunkResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema());
-var ClientConfigRequestSchema = () => _lazy(() => JsonRpcRequestForClientConfigSchema());
-var ClientConfigResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema());
-var GasPriceRequestSchema = () => _lazy(() => JsonRpcRequestForGasPriceSchema());
-var GasPriceResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema());
-var GenesisConfigResponseSchema = () => _lazy(() => JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema());
-var HealthRequestSchema = () => _lazy(() => JsonRpcRequestForHealthSchema());
-var HealthResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema()
-);
-var LightClientProofRequestSchema = () => _lazy(() => JsonRpcRequestForLightClientProofSchema());
-var LightClientProofResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema()
-);
-var MaintenanceWindowsRequestSchema = () => _lazy(() => JsonRpcRequestForMaintenanceWindowsSchema());
-var MaintenanceWindowsResponseSchema = () => _lazy(() => JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema());
-var NetworkInfoRequestSchema = () => _lazy(() => JsonRpcRequestForNetworkInfoSchema());
-var NetworkInfoResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema());
-var NextLightClientBlockRequestSchema = () => _lazy(() => JsonRpcRequestForNextLightClientBlockSchema());
-var NextLightClientBlockResponseSchema = () => _lazy(
-  () => JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema()
-);
-var QueryRequestSchema = () => _lazy(() => JsonRpcRequestForQuerySchema());
-var QueryResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema());
-var SendTxRequestSchema = () => _lazy(() => JsonRpcRequestForSendTxSchema());
-var SendTxResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema());
-var StatusRequestSchema = () => _lazy(() => JsonRpcRequestForStatusSchema());
-var StatusResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema());
-var TxRequestSchema = () => _lazy(() => JsonRpcRequestForTxSchema());
-var TxResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema());
-var ValidatorsRequestSchema = () => _lazy(() => JsonRpcRequestForValidatorsSchema());
-var ValidatorsResponseSchema = () => _lazy(() => JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema());
-var VALIDATION_SCHEMA_MAP = {
-  EXPERIMENTAL_changes: {
-    requestSchema: EXPERIMENTALChangesRequestSchema,
-    responseSchema: EXPERIMENTALChangesResponseSchema
-  },
-  EXPERIMENTAL_changes_in_block: {
-    requestSchema: EXPERIMENTALChangesInBlockRequestSchema,
-    responseSchema: EXPERIMENTALChangesInBlockResponseSchema
-  },
-  EXPERIMENTAL_congestion_level: {
-    requestSchema: EXPERIMENTALCongestionLevelRequestSchema,
-    responseSchema: EXPERIMENTALCongestionLevelResponseSchema
-  },
-  EXPERIMENTAL_genesis_config: {
-    requestSchema: EXPERIMENTALGenesisConfigRequestSchema,
-    responseSchema: EXPERIMENTALGenesisConfigResponseSchema
-  },
-  EXPERIMENTAL_light_client_block_proof: {
-    requestSchema: EXPERIMENTALLightClientBlockProofRequestSchema,
-    responseSchema: EXPERIMENTALLightClientBlockProofResponseSchema
-  },
-  EXPERIMENTAL_light_client_proof: {
-    requestSchema: EXPERIMENTALLightClientProofRequestSchema,
-    responseSchema: EXPERIMENTALLightClientProofResponseSchema
-  },
-  EXPERIMENTAL_maintenance_windows: {
-    requestSchema: EXPERIMENTALMaintenanceWindowsRequestSchema,
-    responseSchema: EXPERIMENTALMaintenanceWindowsResponseSchema
-  },
-  EXPERIMENTAL_protocol_config: {
-    requestSchema: EXPERIMENTALProtocolConfigRequestSchema,
-    responseSchema: EXPERIMENTALProtocolConfigResponseSchema
-  },
-  EXPERIMENTAL_receipt: {
-    requestSchema: EXPERIMENTALReceiptRequestSchema,
-    responseSchema: EXPERIMENTALReceiptResponseSchema
-  },
-  EXPERIMENTAL_split_storage_info: {
-    requestSchema: EXPERIMENTALSplitStorageInfoRequestSchema,
-    responseSchema: EXPERIMENTALSplitStorageInfoResponseSchema
-  },
-  EXPERIMENTAL_tx_status: {
-    requestSchema: EXPERIMENTALTxStatusRequestSchema,
-    responseSchema: EXPERIMENTALTxStatusResponseSchema
-  },
-  EXPERIMENTAL_validators_ordered: {
-    requestSchema: EXPERIMENTALValidatorsOrderedRequestSchema,
-    responseSchema: EXPERIMENTALValidatorsOrderedResponseSchema
-  },
-  block: {
-    requestSchema: BlockRequestSchema,
-    responseSchema: BlockResponseSchema
-  },
-  block_effects: {
-    requestSchema: BlockEffectsRequestSchema,
-    responseSchema: BlockEffectsResponseSchema
-  },
-  broadcast_tx_async: {
-    requestSchema: BroadcastTxAsyncRequestSchema,
-    responseSchema: BroadcastTxAsyncResponseSchema
-  },
-  broadcast_tx_commit: {
-    requestSchema: BroadcastTxCommitRequestSchema,
-    responseSchema: BroadcastTxCommitResponseSchema
-  },
-  changes: {
-    requestSchema: ChangesRequestSchema,
-    responseSchema: ChangesResponseSchema
-  },
-  chunk: {
-    requestSchema: ChunkRequestSchema,
-    responseSchema: ChunkResponseSchema
-  },
-  client_config: {
-    requestSchema: ClientConfigRequestSchema,
-    responseSchema: ClientConfigResponseSchema
-  },
-  gas_price: {
-    requestSchema: GasPriceRequestSchema,
-    responseSchema: GasPriceResponseSchema
-  },
-  genesis_config: {
-    requestSchema: GenesisConfigRequestSchema,
-    responseSchema: GenesisConfigResponseSchema
-  },
-  health: {
-    requestSchema: HealthRequestSchema,
-    responseSchema: HealthResponseSchema
-  },
-  light_client_proof: {
-    requestSchema: LightClientProofRequestSchema,
-    responseSchema: LightClientProofResponseSchema
-  },
-  maintenance_windows: {
-    requestSchema: MaintenanceWindowsRequestSchema,
-    responseSchema: MaintenanceWindowsResponseSchema
-  },
-  network_info: {
-    requestSchema: NetworkInfoRequestSchema,
-    responseSchema: NetworkInfoResponseSchema
-  },
-  next_light_client_block: {
-    requestSchema: NextLightClientBlockRequestSchema,
-    responseSchema: NextLightClientBlockResponseSchema
-  },
-  query: {
-    requestSchema: QueryRequestSchema,
-    responseSchema: QueryResponseSchema
-  },
-  send_tx: {
-    requestSchema: SendTxRequestSchema,
-    responseSchema: SendTxResponseSchema
-  },
-  status: {
-    requestSchema: StatusRequestSchema,
-    responseSchema: StatusResponseSchema
-  },
-  tx: { requestSchema: TxRequestSchema, responseSchema: TxResponseSchema },
-  validators: {
-    requestSchema: ValidatorsRequestSchema,
-    responseSchema: ValidatorsResponseSchema
-  }
-};
 var JsonRpcRequestSchema = () => object({
   jsonrpc: literal("2.0"),
   id: string(),
@@ -4890,132 +4100,215 @@ Object.entries(PATH_TO_METHOD_MAP).forEach(([path, method]) => {
 var RPC_METHODS = Object.values(PATH_TO_METHOD_MAP);
 
 // Auto-generated static RPC functions for tree-shaking
-// Generated at: 2025-07-31T19:21:47.589Z
+// Generated at: 2025-08-03T18:51:29.359Z
 // Total functions: 31
 //
 // This file is automatically generated by tools/codegen/generate-client-interface.ts
 // Do not edit manually - changes will be overwritten
-// EXPERIMENTAL_changes static function
+/**
+ * [Deprecated] Returns changes for a given account, contract or contract code
+ * for given block height or hash. Consider using changes instead.
+ */
 async function experimentalChanges$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_changes', params);
 }
-// EXPERIMENTAL_changes_in_block static function
+/**
+ * [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
+ */
 async function experimentalChangesInBlock$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_changes_in_block', params);
 }
-// EXPERIMENTAL_congestion_level static function
+/**
+ * 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)
+ */
 async function experimentalCongestionLevel$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_congestion_level', params);
 }
-// EXPERIMENTAL_genesis_config static function
+/**
+ * [Deprecated] Get initial state and parameters for the genesis block.
+ * Consider genesis_config instead.
+ */
 async function experimentalGenesisConfig$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_genesis_config', params);
 }
-// EXPERIMENTAL_light_client_block_proof static function
+/** Returns the proofs for a transaction execution. */
 async function experimentalLightClientBlockProof$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_light_client_block_proof', params);
 }
-// EXPERIMENTAL_light_client_proof static function
+/** Returns the proofs for a transaction execution. */
 async function experimentalLightClientProof$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_light_client_proof', params);
 }
-// EXPERIMENTAL_maintenance_windows static function
+/**
+ * [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.
+ */
 async function experimentalMaintenanceWindows$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_maintenance_windows', params);
 }
-// EXPERIMENTAL_protocol_config static function
+/**
+ * A configuration that defines the protocol-level parameters such as
+ * gas/storage costs, limits, feature flags, other settings
+ */
 async function experimentalProtocolConfig$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_protocol_config', params);
 }
-// EXPERIMENTAL_receipt static function
+/** Fetches a receipt by its ID (as is, without a status or execution outcome) */
 async function experimentalReceipt$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_receipt', params);
 }
-// EXPERIMENTAL_split_storage_info static function
+/**
+ * Contains the split storage information. More info on split storage
+ * [here](https://near-nodes.io/archival/split-storage-archival)
+ */
 async function experimentalSplitStorageInfo$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_split_storage_info', params);
 }
-// EXPERIMENTAL_tx_status static function
+/**
+ * Queries status of a transaction by hash, returning the final transaction
+ * result and details of all receipts.
+ */
 async function experimentalTxStatus$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_tx_status', params);
 }
-// EXPERIMENTAL_validators_ordered static function
+/**
+ * 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.
+ */
 async function experimentalValidatorsOrdered$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_validators_ordered', params);
 }
-// block static function
+/** Returns block details for given height or hash */
 async function block$1(client, params) {
     return client.makeRequest('block', params);
 }
-// block_effects static function
+/**
+ * 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.
+ */
 async function blockEffects$1(client, params) {
     return client.makeRequest('block_effects', params);
 }
-// broadcast_tx_async static function
+/**
+ * [Deprecated] Sends a transaction and immediately returns transaction hash.
+ * Consider using send_tx instead.
+ */
 async function broadcastTxAsync$1(client, params) {
     return client.makeRequest('broadcast_tx_async', params);
 }
-// broadcast_tx_commit static function
+/**
+ * [Deprecated] Sends a transaction and waits until transaction is fully
+ * complete. (Has a 10 second timeout). Consider using send_tx instead.
+ */
 async function broadcastTxCommit$1(client, params) {
     return client.makeRequest('broadcast_tx_commit', params);
 }
-// changes static function
+/**
+ * Returns changes for a given account, contract or contract code for given
+ * block height or hash.
+ */
 async function changes$1(client, params) {
     return client.makeRequest('changes', params);
 }
-// chunk static function
+/**
+ * Returns details of a specific chunk. You can run a block details query to
+ * get a valid chunk hash.
+ */
 async function chunk$1(client, params) {
     return client.makeRequest('chunk', params);
 }
-// client_config static function
+/** Queries client node configuration */
 async function clientConfig$1(client, params) {
     return client.makeRequest('client_config', params);
 }
-// gas_price static function
+/**
+ * Returns gas price for a specific block_height or block_hash. Using [null]
+ * will return the most recent block's gas price.
+ */
 async function gasPrice$1(client, params) {
     return client.makeRequest('gas_price', params);
 }
-// genesis_config static function
+/** Get initial state and parameters for the genesis block */
 async function genesisConfig$1(client, params) {
     return client.makeRequest('genesis_config', params);
 }
-// health static function
+/** Returns the current health status of the RPC node the client connects to. */
 async function health$1(client, params) {
     return client.makeRequest('health', params);
 }
-// light_client_proof static function
+/** Returns the proofs for a transaction execution. */
 async function lightClientProof$1(client, params) {
     return client.makeRequest('light_client_proof', params);
 }
-// maintenance_windows static function
+/**
+ * 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.
+ */
 async function maintenanceWindows$1(client, params) {
     return client.makeRequest('maintenance_windows', params);
 }
-// network_info static function
+/**
+ * Queries the current state of node network connections. This includes
+ * information about active peers, transmitted data, known producers, etc.
+ */
 async function networkInfo$1(client, params) {
     return client.makeRequest('network_info', params);
 }
-// next_light_client_block static function
+/** Returns the next light client block. */
 async function nextLightClientBlock$1(client, params) {
     return client.makeRequest('next_light_client_block', params);
 }
-// query static function
+/**
+ * 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.
+ */
 async function query$1(client, params) {
     return client.makeRequest('query', params);
 }
-// send_tx static function
+/**
+ * Sends transaction. Returns the guaranteed execution status and the results
+ * the blockchain can provide at the moment.
+ */
 async function sendTx$1(client, params) {
     return client.makeRequest('send_tx', params);
 }
-// status static function
+/**
+ * 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.
+ */
 async function status$1(client, params) {
     return client.makeRequest('status', params);
 }
-// tx static function
+/**
+ * Queries status of a transaction by hash and returns the final transaction
+ * result.
+ */
 async function tx$1(client, params) {
     return client.makeRequest('tx', params);
 }
-// validators static function
+/**
+ * Queries active validators on the network. Returns details and the state of
+ * validation on the blockchain.
+ */
 async function validators$1(client, params) {
     return client.makeRequest('validators', params);
 }
@@ -5044,11 +4337,15 @@ async function viewFunctionAsJson(client, params) {
 }
 
 // Auto-generated validation wrapper functions
-// Generated at: 2025-07-31T19:21:47.592Z
+// Generated at: 2025-08-03T18:51:29.361Z
 // Total functions: 31
 //
 // This file is automatically generated by tools/codegen/generate-validation-wrappers.ts
 // Do not edit manually - changes will be overwritten
+// Empty enableValidation function (validation is always enabled in these exports)
+function enableValidation() {
+    // Intentionally empty - validation is always enabled for these exports
+}
 // Convenience function wrappers with validation
 async function viewAccount(client, params) {
     // Use the validated query function
@@ -5096,6 +4393,10 @@ async function viewAccessKey(client, params) {
     return query(client, queryParams);
 }
 // Validation wrapper functions
+/**
+ * [Deprecated] Returns changes for a given account, contract or contract code
+ * for given block height or hash. Consider using changes instead.
+ */
 async function experimentalChanges(client, params) {
     // Validate request parameters
     const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
@@ -5120,6 +4421,12 @@ async function experimentalChanges(client, params) {
     }
     return result;
 }
+/**
+ * [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
+ */
 async function experimentalChangesInBlock(client, params) {
     // Validate request parameters
     const requestSchema = RpcStateChangesInBlockRequestSchema();
@@ -5144,6 +4451,10 @@ async function experimentalChangesInBlock(client, params) {
     }
     return result;
 }
+/**
+ * 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)
+ */
 async function experimentalCongestionLevel(client, params) {
     // Validate request parameters
     const requestSchema = RpcCongestionLevelRequestSchema();
@@ -5168,6 +4479,10 @@ async function experimentalCongestionLevel(client, params) {
     }
     return result;
 }
+/**
+ * [Deprecated] Get initial state and parameters for the genesis block.
+ * Consider genesis_config instead.
+ */
 async function experimentalGenesisConfig(client, params) {
     // Validate request parameters
     const requestSchema = GenesisConfigRequestSchema();
@@ -5192,6 +4507,7 @@ async function experimentalGenesisConfig(client, params) {
     }
     return result;
 }
+/** Returns the proofs for a transaction execution. */
 async function experimentalLightClientBlockProof(client, params) {
     // Validate request parameters
     const requestSchema = RpcLightClientBlockProofRequestSchema();
@@ -5216,6 +4532,7 @@ async function experimentalLightClientBlockProof(client, params) {
     }
     return result;
 }
+/** Returns the proofs for a transaction execution. */
 async function experimentalLightClientProof(client, params) {
     // Validate request parameters
     const requestSchema = RpcLightClientExecutionProofRequestSchema();
@@ -5240,6 +4557,12 @@ async function experimentalLightClientProof(client, params) {
     }
     return result;
 }
+/**
+ * [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.
+ */
 async function experimentalMaintenanceWindows(client, params) {
     // Validate request parameters
     const requestSchema = RpcMaintenanceWindowsRequestSchema();
@@ -5254,6 +4577,10 @@ async function experimentalMaintenanceWindows(client, params) {
     // Call the base function (no response validation needed)
     return experimentalMaintenanceWindows$1(client, params);
 }
+/**
+ * A configuration that defines the protocol-level parameters such as
+ * gas/storage costs, limits, feature flags, other settings
+ */
 async function experimentalProtocolConfig(client, params) {
     // Validate request parameters
     const requestSchema = RpcProtocolConfigRequestSchema();
@@ -5278,6 +4605,7 @@ async function experimentalProtocolConfig(client, params) {
     }
     return result;
 }
+/** Fetches a receipt by its ID (as is, without a status or execution outcome) */
 async function experimentalReceipt(client, params) {
     // Validate request parameters
     const requestSchema = RpcReceiptRequestSchema();
@@ -5302,6 +4630,10 @@ async function experimentalReceipt(client, params) {
     }
     return result;
 }
+/**
+ * Contains the split storage information. More info on split storage
+ * [here](https://near-nodes.io/archival/split-storage-archival)
+ */
 async function experimentalSplitStorageInfo(client, params) {
     // Validate request parameters
     const requestSchema = RpcSplitStorageInfoRequestSchema();
@@ -5326,6 +4658,10 @@ async function experimentalSplitStorageInfo(client, params) {
     }
     return result;
 }
+/**
+ * Queries status of a transaction by hash, returning the final transaction
+ * result and details of all receipts.
+ */
 async function experimentalTxStatus(client, params) {
     // Validate request parameters
     const requestSchema = RpcTransactionStatusRequestSchema();
@@ -5350,6 +4686,11 @@ async function experimentalTxStatus(client, params) {
     }
     return result;
 }
+/**
+ * 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.
+ */
 async function experimentalValidatorsOrdered(client, params) {
     // Validate request parameters
     const requestSchema = RpcValidatorsOrderedRequestSchema();
@@ -5364,6 +4705,7 @@ async function experimentalValidatorsOrdered(client, params) {
     // Call the base function (no response validation needed)
     return experimentalValidatorsOrdered$1(client, params);
 }
+/** Returns block details for given height or hash */
 async function block(client, params) {
     // Validate request parameters
     const requestSchema = RpcBlockRequestSchema();
@@ -5388,6 +4730,11 @@ async function block(client, params) {
     }
     return result;
 }
+/**
+ * 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.
+ */
 async function blockEffects(client, params) {
     // Validate request parameters
     const requestSchema = RpcStateChangesInBlockRequestSchema();
@@ -5412,6 +4759,10 @@ async function blockEffects(client, params) {
     }
     return result;
 }
+/**
+ * [Deprecated] Sends a transaction and immediately returns transaction hash.
+ * Consider using send_tx instead.
+ */
 async function broadcastTxAsync(client, params) {
     // Validate request parameters
     const requestSchema = RpcSendTransactionRequestSchema();
@@ -5436,6 +4787,10 @@ async function broadcastTxAsync(client, params) {
     }
     return result;
 }
+/**
+ * [Deprecated] Sends a transaction and waits until transaction is fully
+ * complete. (Has a 10 second timeout). Consider using send_tx instead.
+ */
 async function broadcastTxCommit(client, params) {
     // Validate request parameters
     const requestSchema = RpcSendTransactionRequestSchema();
@@ -5460,6 +4815,10 @@ async function broadcastTxCommit(client, params) {
     }
     return result;
 }
+/**
+ * Returns changes for a given account, contract or contract code for given
+ * block height or hash.
+ */
 async function changes(client, params) {
     // Validate request parameters
     const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
@@ -5484,6 +4843,10 @@ async function changes(client, params) {
     }
     return result;
 }
+/**
+ * Returns details of a specific chunk. You can run a block details query to
+ * get a valid chunk hash.
+ */
 async function chunk(client, params) {
     // Validate request parameters
     const requestSchema = RpcChunkRequestSchema();
@@ -5508,6 +4871,7 @@ async function chunk(client, params) {
     }
     return result;
 }
+/** Queries client node configuration */
 async function clientConfig(client, params) {
     // Validate request parameters
     const requestSchema = RpcClientConfigRequestSchema();
@@ -5532,6 +4896,10 @@ async function clientConfig(client, params) {
     }
     return result;
 }
+/**
+ * Returns gas price for a specific block_height or block_hash. Using [null]
+ * will return the most recent block's gas price.
+ */
 async function gasPrice(client, params) {
     // Validate request parameters
     const requestSchema = RpcGasPriceRequestSchema();
@@ -5556,6 +4924,7 @@ async function gasPrice(client, params) {
     }
     return result;
 }
+/** Get initial state and parameters for the genesis block */
 async function genesisConfig(client, params) {
     // Validate request parameters
     const requestSchema = GenesisConfigRequestSchema();
@@ -5580,6 +4949,7 @@ async function genesisConfig(client, params) {
     }
     return result;
 }
+/** Returns the current health status of the RPC node the client connects to. */
 async function health(client, params) {
     // Validate request parameters
     const requestSchema = RpcHealthRequestSchema();
@@ -5604,6 +4974,7 @@ async function health(client, params) {
     }
     return result;
 }
+/** Returns the proofs for a transaction execution. */
 async function lightClientProof(client, params) {
     // Validate request parameters
     const requestSchema = RpcLightClientExecutionProofRequestSchema();
@@ -5628,6 +4999,11 @@ async function lightClientProof(client, params) {
     }
     return result;
 }
+/**
+ * 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.
+ */
 async function maintenanceWindows(client, params) {
     // Validate request parameters
     const requestSchema = RpcMaintenanceWindowsRequestSchema();
@@ -5642,6 +5018,10 @@ async function maintenanceWindows(client, params) {
     // Call the base function (no response validation needed)
     return maintenanceWindows$1(client, params);
 }
+/**
+ * Queries the current state of node network connections. This includes
+ * information about active peers, transmitted data, known producers, etc.
+ */
 async function networkInfo(client, params) {
     // Validate request parameters
     const requestSchema = RpcNetworkInfoRequestSchema();
@@ -5666,6 +5046,7 @@ async function networkInfo(client, params) {
     }
     return result;
 }
+/** Returns the next light client block. */
 async function nextLightClientBlock(client, params) {
     // Validate request parameters
     const requestSchema = RpcLightClientNextBlockRequestSchema();
@@ -5690,6 +5071,19 @@ async function nextLightClientBlock(client, params) {
     }
     return result;
 }
+/**
+ * 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.
+ */
 async function query(client, params) {
     // Validate request parameters
     const requestSchema = RpcQueryRequestSchema();
@@ -5714,6 +5108,10 @@ async function query(client, params) {
     }
     return result;
 }
+/**
+ * Sends transaction. Returns the guaranteed execution status and the results
+ * the blockchain can provide at the moment.
+ */
 async function sendTx(client, params) {
     // Validate request parameters
     const requestSchema = RpcSendTransactionRequestSchema();
@@ -5738,6 +5136,11 @@ async function sendTx(client, params) {
     }
     return result;
 }
+/**
+ * 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.
+ */
 async function status(client, params) {
     // Validate request parameters
     const requestSchema = RpcStatusRequestSchema();
@@ -5762,6 +5165,10 @@ async function status(client, params) {
     }
     return result;
 }
+/**
+ * Queries status of a transaction by hash and returns the final transaction
+ * result.
+ */
 async function tx(client, params) {
     // Validate request parameters
     const requestSchema = RpcTransactionStatusRequestSchema();
@@ -5786,6 +5193,10 @@ async function tx(client, params) {
     }
     return result;
 }
+/**
+ * Queries active validators on the network. Returns details and the state of
+ * validation on the blockchain.
+ */
 async function validators(client, params) {
     // Validate request parameters
     const requestSchema = RpcValidatorRequestSchema();
@@ -5811,76 +5222,4 @@ async function validators(client, params) {
     return result;
 }
 
-// Optional validation for client - only imported when explicitly enabled
-/**
- * Enable validation for the client
- * This function should only be called if you want to include schema validation
- * Calling this function will include Zod schemas in your bundle
- */
-function enableValidation() {
-    const requestSchema = JsonRpcRequestSchema();
-    const responseSchema = JsonRpcResponseSchema();
-    return {
-        validateRequest: (request) => {
-            try {
-                requestSchema.parse(request);
-            }
-            catch (error) {
-                throw new JsonRpcNetworkError(`Invalid request format: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
-            }
-        },
-        validateResponse: (response) => {
-            try {
-                responseSchema.parse(response);
-            }
-            catch (error) {
-                throw new JsonRpcClientError(`Invalid response format: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        },
-        validateMethodRequest: (method, request) => {
-            try {
-                // First validate basic JSON-RPC structure
-                requestSchema.parse(request);
-                // Then validate method-specific structure if schema exists
-                const methodSchemas = VALIDATION_SCHEMA_MAP[method];
-                if (methodSchemas?.requestSchema) {
-                    const methodRequestSchema = methodSchemas.requestSchema();
-                    methodRequestSchema.parse(request);
-                }
-            }
-            catch (error) {
-                throw new JsonRpcNetworkError(`Invalid ${method} request: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
-            }
-        },
-        validateMethodResponse: (method, response) => {
-            try {
-                // First validate basic JSON-RPC structure
-                responseSchema.parse(response);
-                // Check if the result contains an error field before validating the schema
-                // This provides a better error message when NEAR RPC returns non-standard errors
-                if (response.result &&
-                    typeof response.result === 'object' &&
-                    'error' in response.result) {
-                    const serverError = response.result.error;
-                    throw new JsonRpcClientError(`Server error: ${serverError}`, -32000, response.result);
-                }
-                // Then validate method-specific response structure if schema exists
-                const methodSchemas = VALIDATION_SCHEMA_MAP[method];
-                if (methodSchemas?.responseSchema) {
-                    const methodResponseSchema = methodSchemas.responseSchema();
-                    methodResponseSchema.parse(response);
-                }
-            }
-            catch (error) {
-                // If it's already a JsonRpcClientError (from server error check), re-throw it
-                if (error instanceof JsonRpcClientError) {
-                    throw error;
-                }
-                // Otherwise, it's a validation error
-                throw new JsonRpcClientError(`Invalid ${method} response: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        },
-    };
-}
-
 export { JsonRpcClientError, JsonRpcNetworkError, JsonRpcRequestSchema, JsonRpcResponseSchema, NearRpcClient, NearRpcError, RPC_METHODS, block, blockEffects, broadcastTxAsync, broadcastTxCommit, changes, chunk, clientConfig, NearRpcClient as default, defaultClient, enableValidation, experimentalChanges, experimentalChangesInBlock, experimentalCongestionLevel, experimentalGenesisConfig, experimentalLightClientBlockProof, experimentalLightClientProof, experimentalMaintenanceWindows, experimentalProtocolConfig, experimentalReceipt, experimentalSplitStorageInfo, experimentalTxStatus, experimentalValidatorsOrdered, gasPrice, genesisConfig, health, lightClientProof, maintenanceWindows, networkInfo, nextLightClientBlock, parseCallResultToJson, query, sendTx, status, tx, validators, viewAccessKey, viewAccount, viewFunction, viewFunctionAsJson };