@psalomo/jsonrpc-client 1.0.1 → 1.0.3

package/dist/browser-standalone.js

@@ -48,9 +48,11 @@ class JsonRpcClientError extends Error {
 }
 class JsonRpcNetworkError extends Error {
     originalError;
-    constructor(message, originalError) {
+    responseBody;
+    constructor(message, originalError, responseBody) {
         super(message);
         this.originalError = originalError;
+        this.responseBody = responseBody;
         this.name = 'JsonRpcNetworkError';
     }
 }
@@ -87,23 +89,31 @@ class NearRpcClient {
      * This is used internally by the standalone RPC functions
      */
     async makeRequest(method, params) {
-        // Convert camelCase params to snake_case for the RPC call
-        const snakeCaseParams = params ? convertKeysToSnakeCase(params) : params;
-        const request = {
+        // Create request with original camelCase params for validation
+        const requestForValidation = {
             jsonrpc: '2.0',
             id: REQUEST_ID,
             method,
-            params: snakeCaseParams,
+            params: params !== undefined ? params : null,
         };
-        // Validate request if validation is enabled
+        // Validate request if validation is enabled (before snake_case conversion)
         if (this.validation) {
             if ('validateMethodRequest' in this.validation) {
-                this.validation.validateMethodRequest(method, request);
+                this.validation.validateMethodRequest(method, requestForValidation);
             }
             else {
-                this.validation.validateRequest(request);
+                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;
+        const request = {
+            jsonrpc: '2.0',
+            id: REQUEST_ID,
+            method,
+            params: snakeCaseParams,
+        };
         let lastError = null;
         for (let attempt = 0; attempt <= this.retries; attempt++) {
             try {
@@ -119,23 +129,29 @@ class NearRpcClient {
                     signal: controller.signal,
                 });
                 clearTimeout(timeoutId);
-                if (!response.ok) {
-                    throw new JsonRpcNetworkError(`HTTP error! status: ${response.status}`);
-                }
                 let jsonResponse;
                 try {
                     jsonResponse = await response.json();
                 }
                 catch (parseError) {
+                    // If we can't parse JSON and it's not a 2xx response, include status info
+                    if (!response.ok) {
+                        throw new JsonRpcNetworkError(`HTTP error! status: ${response.status} - Failed to parse JSON response`, parseError);
+                    }
                     throw new JsonRpcNetworkError('Failed to parse JSON response', parseError);
                 }
-                // Validate basic JSON-RPC response structure first
-                if (this.validation) {
-                    this.validation.validateResponse(jsonResponse);
-                }
+                // Check for JSON-RPC error in the response
                 if (jsonResponse.error) {
                     throw new JsonRpcClientError(jsonResponse.error.message, jsonResponse.error.code, jsonResponse.error.data);
                 }
+                // If it's not a 2xx status and no JSON-RPC error, throw network error with body
+                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)
@@ -1514,7 +1530,9 @@ var AccessKeyPermissionViewSchema = () => union([
   _enum(["FullAccess"]),
   object({
     FunctionCall: object({
-      allowance: optional(string()),
+      allowance: optional(
+        union([union([string(), _null()]), _null()])
+      ),
       methodNames: array(string()),
       receiverId: string()
     })
@@ -1607,7 +1625,7 @@ var ActionCreationConfigViewSchema = () => object({
   transferCost: _lazy(() => FeeSchema())
 });
 var ActionErrorSchema = () => object({
-  index: optional(number()),
+  index: optional(union([union([number(), _null()]), _null()])),
   kind: _lazy(() => ActionErrorKindSchema())
 });
 var ActionErrorKindSchema = () => union([
@@ -1895,10 +1913,14 @@ var BlockHeaderViewSchema = () => object({
     union([_lazy(() => CryptoHashSchema()), _null()])
   ),
   blockMerkleRoot: _lazy(() => CryptoHashSchema()),
-  blockOrdinal: optional(number()),
+  blockOrdinal: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   challengesResult: array(_lazy(() => SlashedValidatorSchema())),
   challengesRoot: _lazy(() => CryptoHashSchema()),
-  chunkEndorsements: optional(array(array(number()))),
+  chunkEndorsements: optional(
+    union([union([array(array(number())), _null()]), _null()])
+  ),
   chunkHeadersRoot: _lazy(() => CryptoHashSchema()),
   chunkMask: array(boolean()),
   chunkReceiptsRoot: _lazy(() => CryptoHashSchema()),
@@ -1918,7 +1940,9 @@ var BlockHeaderViewSchema = () => object({
   nextEpochId: _lazy(() => CryptoHashSchema()),
   outcomeRoot: _lazy(() => CryptoHashSchema()),
   prevHash: _lazy(() => CryptoHashSchema()),
-  prevHeight: optional(number()),
+  prevHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   prevStateRoot: _lazy(() => CryptoHashSchema()),
   randomValue: _lazy(() => CryptoHashSchema()),
   rentPaid: string(),
@@ -2081,12 +2105,19 @@ var DetailedDebugStatusSchema = () => object({
 });
 var DirectionSchema = () => _enum(["Left", "Right"]);
 var DumpConfigSchema = () => object({
-  credentialsFile: optional(string()),
+  credentialsFile: optional(
+    union([union([string(), _null()]), _null()])
+  ),
   iterationDelay: optional(
     union([_lazy(() => DurationAsStdSchemaProviderSchema()), _null()])
   ),
   location: _lazy(() => ExternalStorageLocationSchema()),
-  restartDumpForShards: optional(array(_lazy(() => ShardIdSchema())))
+  restartDumpForShards: optional(
+    union([
+      union([array(_lazy(() => ShardIdSchema())), _null()]),
+      _null()
+    ])
+  )
 });
 var DurationAsStdSchemaProviderSchema = () => object({
   nanos: number(),
@@ -2100,7 +2131,12 @@ var EpochSyncConfigSchema = () => object({
   timeoutForEpochSync: _lazy(() => DurationAsStdSchemaProviderSchema())
 });
 var ExecutionMetadataViewSchema = () => object({
-  gasProfile: optional(array(_lazy(() => CostGasUsedSchema()))),
+  gasProfile: optional(
+    union([
+      union([array(_lazy(() => CostGasUsedSchema())), _null()]),
+      _null()
+    ])
+  ),
   version: number()
 });
 var ExecutionOutcomeViewSchema = () => object({
@@ -2303,7 +2339,7 @@ var FunctionCallErrorSchema = () => union([
   })
 ]);
 var FunctionCallPermissionSchema = () => object({
-  allowance: optional(string()),
+  allowance: optional(union([union([string(), _null()]), _null()])),
   methodNames: array(string()),
   receiverId: string()
 });
@@ -2672,6 +2708,12 @@ var JsonRpcRequestForBlockSchema = () => object({
   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(),
@@ -2720,6 +2762,12 @@ var JsonRpcRequestForLightClientProofSchema = () => object({
   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(),
@@ -2762,193 +2810,336 @@ var JsonRpcRequestForValidatorsSchema = () => object({
   method: _enum(["validators"]),
   params: _lazy(() => RpcValidatorRequestSchema())
 });
-var JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema = () => union([
-  object({
-    result: array(_lazy(() => RangeOfUint64Schema()))
-  }),
+var JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: array(_lazy(() => RangeOfUint64Schema()))
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema = () => union([
-  object({
-    result: array(_lazy(() => ValidatorStakeViewSchema()))
-  }),
+);
+var JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: array(_lazy(() => ValidatorStakeViewSchema()))
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => CryptoHashSchema())
-  }),
+);
+var JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => CryptoHashSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => GenesisConfigSchema())
-  }),
+);
+var JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => GenesisConfigSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: union([_lazy(() => RpcHealthResponseSchema()), _null()])
-  }),
+);
+var JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: union([_lazy(() => RpcHealthResponseSchema()), _null()])
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcChunkResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcChunkResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcClientConfigResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcClientConfigResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcCongestionLevelResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcCongestionLevelResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcGasPriceResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcGasPriceResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientBlockProofResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientBlockProofResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientExecutionProofResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientExecutionProofResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientNextBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientNextBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcNetworkInfoResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcNetworkInfoResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcProtocolConfigResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcProtocolConfigResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcQueryResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcQueryResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcReceiptResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcReceiptResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcSplitStorageInfoResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcSplitStorageInfoResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStateChangesInBlockByTypeResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStateChangesInBlockByTypeResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStateChangesInBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStateChangesInBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStatusResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStatusResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcTransactionResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcTransactionResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcValidatorResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcValidatorResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
+);
 var KnownProducerViewSchema = () => object({
   accountId: _lazy(() => AccountIdSchema()),
-  nextHops: optional(array(_lazy(() => PublicKeySchema()))),
+  nextHops: optional(
+    union([
+      union([array(_lazy(() => PublicKeySchema())), _null()]),
+      _null()
+    ])
+  ),
   peerId: _lazy(() => PublicKeySchema())
 });
 var LightClientBlockLiteViewSchema = () => object({
@@ -2964,13 +3155,17 @@ var LimitConfigSchema = () => object({
   maxActionsPerReceipt: number(),
   maxArgumentsLength: number(),
   maxContractSize: number(),
-  maxFunctionsNumberPerContract: optional(number()),
+  maxFunctionsNumberPerContract: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   maxGasBurnt: number(),
   maxLengthMethodName: number(),
   maxLengthReturnedData: number(),
   maxLengthStorageKey: number(),
   maxLengthStorageValue: number(),
-  maxLocalsPerContract: optional(number()),
+  maxLocalsPerContract: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   maxMemoryPages: number(),
   maxNumberBytesMethodNames: number(),
   maxNumberInputDataDependencies: number(),
@@ -3030,7 +3225,7 @@ var PeerInfoViewSchema = () => object({
     union([_lazy(() => CryptoHashSchema()), _null()])
   ),
   connectionEstablishedTimeMillis: number(),
-  height: optional(number()),
+  height: optional(union([union([number(), _null()]), _null()])),
   isHighestBlockInvalid: boolean(),
   isOutboundPeer: boolean(),
   lastTimePeerRequestedMillis: number(),
@@ -3071,7 +3266,7 @@ var ReceiptEnumViewSchema = () => union([
   }),
   object({
     Data: object({
-      data: optional(string()),
+      data: optional(union([union([string(), _null()]), _null()])),
       dataId: _lazy(() => CryptoHashSchema()),
       isPromiseResume: optional(boolean())
     })
@@ -3178,6 +3373,7 @@ var RpcClientConfigResponseSchema = () => object({
     union([_lazy(() => ChunkDistributionNetworkConfigSchema()), _null()])
   ),
   chunkRequestRetryPeriod: array(number()),
+  chunkValidationThreads: number(),
   chunkWaitMult: array(number()),
   clientBackgroundMigrationThreads: number(),
   doomslugStepPeriod: array(number()),
@@ -3195,7 +3391,9 @@ var RpcClientConfigResponseSchema = () => object({
   logSummaryStyle: _lazy(() => LogSummaryStyleSchema()),
   maxBlockProductionDelay: array(number()),
   maxBlockWaitDelay: array(number()),
-  maxGasBurntView: optional(number()),
+  maxGasBurntView: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   minBlockProductionDelay: array(number()),
   minNumPeers: number(),
   numBlockProducerSeats: number(),
@@ -3204,12 +3402,15 @@ var RpcClientConfigResponseSchema = () => object({
   produceChunkAddTransactionsTimeLimit: string(),
   produceEmptyBlocks: boolean(),
   reshardingConfig: _lazy(() => MutableConfigValueSchema()),
-  rpcAddr: optional(string()),
+  rpcAddr: optional(union([union([string(), _null()]), _null()])),
   saveInvalidWitnesses: boolean(),
   saveLatestWitnesses: boolean(),
   saveTrieChanges: boolean(),
   saveTxOutcomes: boolean(),
   skipSyncWait: boolean(),
+  stateRequestServerThreads: number(),
+  stateRequestThrottlePeriod: array(number()),
+  stateRequestsPerThrottlePeriod: number(),
   stateSync: _lazy(() => StateSyncConfigSchema()),
   stateSyncEnabled: boolean(),
   stateSyncExternalBackoff: array(number()),
@@ -3221,15 +3422,17 @@ var RpcClientConfigResponseSchema = () => object({
   syncMaxBlockRequests: number(),
   syncStepPeriod: array(number()),
   trackedShardsConfig: _lazy(() => TrackedShardsConfigSchema()),
-  transactionPoolSizeLimit: optional(number()),
+  transactionPoolSizeLimit: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   transactionRequestHandlerThreads: number(),
-  trieViewerStateSizeLimit: optional(number()),
+  trieViewerStateSizeLimit: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   ttlAccountIdRouter: array(number()),
   txRoutingHeightHorizon: number(),
   version: _lazy(() => VersionSchema()),
-  viewClientNumStateRequestsPerThrottlePeriod: number(),
-  viewClientThreads: number(),
-  viewClientThrottlePeriod: array(number())
+  viewClientThreads: number()
 });
 var RpcCongestionLevelRequestSchema = () => union([
   object({
@@ -3243,20 +3446,29 @@ var RpcCongestionLevelRequestSchema = () => union([
 var RpcCongestionLevelResponseSchema = () => object({
   congestionLevel: number()
 });
-var RpcErrorSchema = () => union([
-  object({
-    cause: _lazy(() => RpcRequestValidationErrorKindSchema()),
-    name: _enum(["REQUEST_VALIDATION_ERROR"])
-  }),
-  object({
-    cause: unknown(),
-    name: _enum(["HANDLER_ERROR"])
-  }),
+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: unknown(),
-    name: _enum(["INTERNAL_ERROR"])
+    cause: optional(unknown()),
+    code: number(),
+    data: optional(unknown()),
+    message: string(),
+    name: optional(unknown())
   })
-]);
+);
 var RpcGasPriceRequestSchema = () => object({
   blockId: optional(union([_lazy(() => BlockIdSchema()), _null()]))
 });
@@ -3267,7 +3479,7 @@ var RpcHealthRequestSchema = () => _null();
 var RpcHealthResponseSchema = () => _null();
 var RpcKnownProducerSchema = () => object({
   accountId: _lazy(() => AccountIdSchema()),
-  addr: optional(string()),
+  addr: optional(union([union([string(), _null()]), _null()])),
   peerId: _lazy(() => PeerIdSchema())
 });
 var RpcLightClientBlockProofRequestSchema = () => object({
@@ -3278,18 +3490,23 @@ var RpcLightClientBlockProofResponseSchema = () => object({
   blockHeaderLite: _lazy(() => LightClientBlockLiteViewSchema()),
   blockProof: array(_lazy(() => MerklePathItemSchema()))
 });
-var RpcLightClientExecutionProofRequestSchema = () => union([
-  object({
-    senderId: _lazy(() => AccountIdSchema()),
-    transactionHash: _lazy(() => CryptoHashSchema()),
-    type: _enum(["transaction"])
-  }),
+var RpcLightClientExecutionProofRequestSchema = () => intersection(
+  union([
+    object({
+      senderId: _lazy(() => AccountIdSchema()),
+      transactionHash: _lazy(() => CryptoHashSchema()),
+      type: _enum(["transaction"])
+    }),
+    object({
+      receiptId: _lazy(() => CryptoHashSchema()),
+      receiverId: _lazy(() => AccountIdSchema()),
+      type: _enum(["receipt"])
+    })
+  ]),
   object({
-    receiptId: _lazy(() => CryptoHashSchema()),
-    receiverId: _lazy(() => AccountIdSchema()),
-    type: _enum(["receipt"])
+    lightClientHead: _lazy(() => CryptoHashSchema())
   })
-]);
+);
 var RpcLightClientExecutionProofResponseSchema = () => object({
   blockHeaderLite: _lazy(() => LightClientBlockLiteViewSchema()),
   blockProof: array(_lazy(() => MerklePathItemSchema())),
@@ -3306,7 +3523,12 @@ var RpcLightClientNextBlockResponseSchema = () => object({
   innerLite: optional(_lazy(() => BlockHeaderInnerLiteViewSchema())),
   innerRestHash: optional(_lazy(() => CryptoHashSchema())),
   nextBlockInnerHash: optional(_lazy(() => CryptoHashSchema())),
-  nextBps: optional(array(_lazy(() => ValidatorStakeViewSchema()))),
+  nextBps: optional(
+    union([
+      union([array(_lazy(() => ValidatorStakeViewSchema())), _null()]),
+      _null()
+    ])
+  ),
   prevBlockHash: optional(_lazy(() => CryptoHashSchema()))
 });
 var RpcMaintenanceWindowsRequestSchema = () => object({
@@ -3323,7 +3545,7 @@ var RpcNetworkInfoResponseSchema = () => object({
 });
 var RpcPeerInfoSchema = () => object({
   accountId: optional(union([_lazy(() => AccountIdSchema()), _null()])),
-  addr: optional(string()),
+  addr: optional(union([union([string(), _null()]), _null()])),
   id: _lazy(() => PeerIdSchema())
 });
 var RpcProtocolConfigRequestSchema = () => union([
@@ -3643,10 +3865,16 @@ var RpcSendTransactionRequestSchema = () => object({
 });
 var RpcSplitStorageInfoRequestSchema = () => record(string(), unknown());
 var RpcSplitStorageInfoResponseSchema = () => object({
-  coldHeadHeight: optional(number()),
-  finalHeadHeight: optional(number()),
-  headHeight: optional(number()),
-  hotDbKind: optional(string())
+  coldHeadHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
+  finalHeadHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
+  headHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
+  hotDbKind: optional(union([union([string(), _null()]), _null()]))
 });
 var RpcStateChangesInBlockByTypeRequestSchema = () => union([
   intersection(
@@ -3872,7 +4100,7 @@ var RpcStatusResponseSchema = () => object({
   nodeKey: optional(union([_lazy(() => PublicKeySchema()), _null()])),
   nodePublicKey: _lazy(() => PublicKeySchema()),
   protocolVersion: number(),
-  rpcAddr: optional(string()),
+  rpcAddr: optional(union([union([string(), _null()]), _null()])),
   syncInfo: _lazy(() => StatusSyncInfoSchema()),
   uptimeSec: number(),
   validatorAccountId: optional(
@@ -3955,8 +4183,18 @@ var ShardLayoutV0Schema = () => object({
 });
 var ShardLayoutV1Schema = () => object({
   boundaryAccounts: array(_lazy(() => AccountIdSchema())),
-  shardsSplitMap: optional(array(array(_lazy(() => ShardIdSchema())))),
-  toParentShardMap: optional(array(_lazy(() => ShardIdSchema()))),
+  shardsSplitMap: optional(
+    union([
+      union([array(array(_lazy(() => ShardIdSchema()))), _null()]),
+      _null()
+    ])
+  ),
+  toParentShardMap: optional(
+    union([
+      union([array(_lazy(() => ShardIdSchema())), _null()]),
+      _null()
+    ])
+  ),
   version: number()
 });
 var ShardLayoutV2Schema = () => object({
@@ -3968,13 +4206,25 @@ var ShardLayoutV2Schema = () => object({
   ),
   shardIds: array(_lazy(() => ShardIdSchema())),
   shardsParentMap: optional(
-    record(
-      string(),
-      _lazy(() => ShardIdSchema())
-    )
+    union([
+      union([
+        record(
+          string(),
+          _lazy(() => ShardIdSchema())
+        ),
+        _null()
+      ]),
+      _null()
+    ])
   ),
   shardsSplitMap: optional(
-    record(string(), array(_lazy(() => ShardIdSchema())))
+    union([
+      union([
+        record(string(), array(_lazy(() => ShardIdSchema()))),
+        _null()
+      ]),
+      _null()
+    ])
   ),
   version: number()
 });
@@ -4006,6 +4256,46 @@ var StakeActionSchema = () => object({
   publicKey: _lazy(() => PublicKeySchema()),
   stake: string()
 });
+var StateChangeCauseViewSchema = () => union([
+  object({
+    type: _enum(["not_writable_to_disk"])
+  }),
+  object({
+    type: _enum(["initial_state"])
+  }),
+  object({
+    txHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["transaction_processing"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["action_receipt_processing_started"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["action_receipt_gas_reward"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["receipt_processing"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["postponed_receipt"])
+  }),
+  object({
+    type: _enum(["updated_delayed_receipts"])
+  }),
+  object({
+    type: _enum(["validator_accounts_update"])
+  }),
+  object({
+    type: _enum(["migration"])
+  }),
+  object({
+    type: _enum(["bandwidth_scheduler_state_update"])
+  })
+]);
 var StateChangeKindViewSchema = () => union([
   object({
     accountId: _lazy(() => AccountIdSchema()),
@@ -4024,98 +4314,103 @@ var StateChangeKindViewSchema = () => union([
     type: _enum(["contract_code_touched"])
   })
 ]);
-var StateChangeWithCauseViewSchema = () => union([
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      amount: string(),
-      codeHash: _lazy(() => CryptoHashSchema()),
-      globalContractAccountId: optional(
-        union([_lazy(() => AccountIdSchema()), _null()])
-      ),
-      globalContractHash: optional(
-        union([_lazy(() => CryptoHashSchema()), _null()])
-      ),
-      locked: string(),
-      storagePaidAt: optional(number()),
-      storageUsage: number()
+var StateChangeWithCauseViewSchema = () => intersection(
+  union([
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        amount: string(),
+        codeHash: _lazy(() => CryptoHashSchema()),
+        globalContractAccountId: optional(
+          union([_lazy(() => AccountIdSchema()), _null()])
+        ),
+        globalContractHash: optional(
+          union([_lazy(() => CryptoHashSchema()), _null()])
+        ),
+        locked: string(),
+        storagePaidAt: optional(number()),
+        storageUsage: number()
+      }),
+      type: _enum(["account_update"])
     }),
-    type: _enum(["account_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema())
+      }),
+      type: _enum(["account_deletion"])
     }),
-    type: _enum(["account_deletion"])
-  }),
-  object({
-    change: object({
-      accessKey: _lazy(() => AccessKeyViewSchema()),
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accessKey: _lazy(() => AccessKeyViewSchema()),
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["access_key_update"])
     }),
-    type: _enum(["access_key_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["access_key_deletion"])
     }),
-    type: _enum(["access_key_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      gasKey: _lazy(() => GasKeyViewSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        gasKey: _lazy(() => GasKeyViewSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_update"])
     }),
-    type: _enum(["gas_key_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      index: number(),
-      nonce: number(),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        index: number(),
+        nonce: number(),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_nonce_update"])
     }),
-    type: _enum(["gas_key_nonce_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_deletion"])
     }),
-    type: _enum(["gas_key_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      keyBase64: _lazy(() => StoreKeySchema()),
-      valueBase64: _lazy(() => StoreValueSchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        keyBase64: _lazy(() => StoreKeySchema()),
+        valueBase64: _lazy(() => StoreValueSchema())
+      }),
+      type: _enum(["data_update"])
     }),
-    type: _enum(["data_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      keyBase64: _lazy(() => StoreKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        keyBase64: _lazy(() => StoreKeySchema())
+      }),
+      type: _enum(["data_deletion"])
     }),
-    type: _enum(["data_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      codeBase64: string()
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        codeBase64: string()
+      }),
+      type: _enum(["contract_code_update"])
     }),
-    type: _enum(["contract_code_update"])
-  }),
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema())
+      }),
+      type: _enum(["contract_code_deletion"])
+    })
+  ]),
   object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema())
-    }),
-    type: _enum(["contract_code_deletion"])
+    cause: _lazy(() => StateChangeCauseViewSchema())
   })
-]);
+);
 var StateItemSchema = () => object({
   key: _lazy(() => StoreKeySchema()),
   value: _lazy(() => StoreValueSchema())
@@ -4129,10 +4424,16 @@ var StatusSyncInfoSchema = () => object({
   earliestBlockHash: optional(
     union([_lazy(() => CryptoHashSchema()), _null()])
   ),
-  earliestBlockHeight: optional(number()),
-  earliestBlockTime: optional(string()),
+  earliestBlockHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
+  earliestBlockTime: optional(
+    union([union([string(), _null()]), _null()])
+  ),
   epochId: optional(union([_lazy(() => EpochIdSchema()), _null()])),
-  epochStartHeight: optional(number()),
+  epochStartHeight: optional(
+    union([union([number(), _null()]), _null()])
+  ),
   latestBlockHash: _lazy(() => CryptoHashSchema()),
   latestBlockHeight: number(),
   latestBlockTime: string(),
@@ -4355,6 +4656,10 @@ var EXPERIMENTALValidatorsOrderedResponseSchema = () => _lazy(
 );
 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());
@@ -4369,6 +4674,7 @@ var ClientConfigRequestSchema = () => _lazy(() => JsonRpcRequestForClientConfigS
 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()
@@ -4377,6 +4683,8 @@ var LightClientProofRequestSchema = () => _lazy(() => JsonRpcRequestForLightClie
 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());
@@ -4446,6 +4754,10 @@ var VALIDATION_SCHEMA_MAP = {
     requestSchema: BlockRequestSchema,
     responseSchema: BlockResponseSchema
   },
+  block_effects: {
+    requestSchema: BlockEffectsRequestSchema,
+    responseSchema: BlockEffectsResponseSchema
+  },
   broadcast_tx_async: {
     requestSchema: BroadcastTxAsyncRequestSchema,
     responseSchema: BroadcastTxAsyncResponseSchema
@@ -4470,6 +4782,10 @@ var VALIDATION_SCHEMA_MAP = {
     requestSchema: GasPriceRequestSchema,
     responseSchema: GasPriceResponseSchema
   },
+  genesis_config: {
+    requestSchema: GenesisConfigRequestSchema,
+    responseSchema: GenesisConfigResponseSchema
+  },
   health: {
     requestSchema: HealthRequestSchema,
     responseSchema: HealthResponseSchema
@@ -4478,6 +4794,10 @@ var VALIDATION_SCHEMA_MAP = {
     requestSchema: LightClientProofRequestSchema,
     responseSchema: LightClientProofResponseSchema
   },
+  maintenance_windows: {
+    requestSchema: MaintenanceWindowsRequestSchema,
+    responseSchema: MaintenanceWindowsResponseSchema
+  },
   network_info: {
     requestSchema: NetworkInfoRequestSchema,
     responseSchema: NetworkInfoResponseSchema
@@ -4537,14 +4857,17 @@ var PATH_TO_METHOD_MAP = {
   "/EXPERIMENTAL_tx_status": "EXPERIMENTAL_tx_status",
   "/EXPERIMENTAL_validators_ordered": "EXPERIMENTAL_validators_ordered",
   "/block": "block",
+  "/block_effects": "block_effects",
   "/broadcast_tx_async": "broadcast_tx_async",
   "/broadcast_tx_commit": "broadcast_tx_commit",
   "/changes": "changes",
   "/chunk": "chunk",
   "/client_config": "client_config",
   "/gas_price": "gas_price",
+  "/genesis_config": "genesis_config",
   "/health": "health",
   "/light_client_proof": "light_client_proof",
+  "/maintenance_windows": "maintenance_windows",
   "/network_info": "network_info",
   "/next_light_client_block": "next_light_client_block",
   "/query": "query",
@@ -4558,8 +4881,8 @@ 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-26T17:05:05.177Z
-// Total functions: 28
+// Generated at: 2025-07-29T20:18:38.221Z
+// Total functions: 31
 //
 // This file is automatically generated by tools/codegen/generate-client-interface.ts
 // Do not edit manually - changes will be overwritten
@@ -4615,6 +4938,10 @@ async function experimentalValidatorsOrdered(client, params) {
 async function block(client, params) {
     return client.makeRequest('block', params);
 }
+// block_effects static function
+async function blockEffects(client, params) {
+    return client.makeRequest('block_effects', params);
+}
 // broadcast_tx_async static function
 async function broadcastTxAsync(client, params) {
     return client.makeRequest('broadcast_tx_async', params);
@@ -4639,6 +4966,10 @@ async function clientConfig(client, params) {
 async function gasPrice(client, params) {
     return client.makeRequest('gas_price', params);
 }
+// genesis_config static function
+async function genesisConfig(client, params) {
+    return client.makeRequest('genesis_config', params);
+}
 // health static function
 async function health(client, params) {
     return client.makeRequest('health', params);
@@ -4647,6 +4978,10 @@ async function health(client, params) {
 async function lightClientProof(client, params) {
     return client.makeRequest('light_client_proof', params);
 }
+// maintenance_windows static function
+async function maintenanceWindows(client, params) {
+    return client.makeRequest('maintenance_windows', params);
+}
 // network_info static function
 async function networkInfo(client, params) {
     return client.makeRequest('network_info', params);
@@ -4781,4 +5116,4 @@ function enableValidation() {
     };
 }
 
-export { JsonRpcClientError, JsonRpcNetworkError, JsonRpcRequestSchema, JsonRpcResponseSchema, NearRpcClient, NearRpcError, RPC_METHODS, block, broadcastTxAsync, broadcastTxCommit, changes, chunk, clientConfig, NearRpcClient as default, defaultClient, enableValidation, experimentalChanges, experimentalChangesInBlock, experimentalCongestionLevel, experimentalGenesisConfig, experimentalLightClientBlockProof, experimentalLightClientProof, experimentalMaintenanceWindows, experimentalProtocolConfig, experimentalReceipt, experimentalSplitStorageInfo, experimentalTxStatus, experimentalValidatorsOrdered, gasPrice, health, lightClientProof, networkInfo, nextLightClientBlock, query, sendTx, status, tx, validators, viewAccessKey, viewAccount, viewFunction };
+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, query, sendTx, status, tx, validators, viewAccessKey, viewAccount, viewFunction };