diff --git a/src/api/@tanstack/react-query.gen.ts b/src/api/@tanstack/react-query.gen.ts index 85cfa5f41..1e531c0ff 100644 --- a/src/api/@tanstack/react-query.gen.ts +++ b/src/api/@tanstack/react-query.gen.ts @@ -268,6 +268,8 @@ import { intBlockOpcodeGasServiceList, intBlockProposerCanonicalServiceGet, intBlockProposerCanonicalServiceList, + intBlockResourceGasServiceGet, + intBlockResourceGasServiceList, intContractCreationServiceGet, intContractCreationServiceList, intContractSelfdestructServiceGet, @@ -362,10 +364,14 @@ import { intStorageSlotStateWithExpiryServiceList, intTransactionCallFrameOpcodeGasServiceGet, intTransactionCallFrameOpcodeGasServiceList, + intTransactionCallFrameOpcodeResourceGasServiceGet, + intTransactionCallFrameOpcodeResourceGasServiceList, intTransactionCallFrameServiceGet, intTransactionCallFrameServiceList, intTransactionOpcodeGasServiceGet, intTransactionOpcodeGasServiceList, + intTransactionResourceGasServiceGet, + intTransactionResourceGasServiceList, type Options, } from '../sdk.gen'; import type { @@ -1161,6 +1167,12 @@ import type { IntBlockProposerCanonicalServiceListData, IntBlockProposerCanonicalServiceListError, IntBlockProposerCanonicalServiceListResponse, + IntBlockResourceGasServiceGetData, + IntBlockResourceGasServiceGetError, + IntBlockResourceGasServiceGetResponse, + IntBlockResourceGasServiceListData, + IntBlockResourceGasServiceListError, + IntBlockResourceGasServiceListResponse, IntContractCreationServiceGetData, IntContractCreationServiceGetError, IntContractCreationServiceGetResponse, @@ -1443,6 +1455,12 @@ import type { IntTransactionCallFrameOpcodeGasServiceListData, IntTransactionCallFrameOpcodeGasServiceListError, IntTransactionCallFrameOpcodeGasServiceListResponse, + IntTransactionCallFrameOpcodeResourceGasServiceGetData, + IntTransactionCallFrameOpcodeResourceGasServiceGetError, + IntTransactionCallFrameOpcodeResourceGasServiceGetResponse, + IntTransactionCallFrameOpcodeResourceGasServiceListData, + IntTransactionCallFrameOpcodeResourceGasServiceListError, + IntTransactionCallFrameOpcodeResourceGasServiceListResponse, IntTransactionCallFrameServiceGetData, IntTransactionCallFrameServiceGetError, IntTransactionCallFrameServiceGetResponse, @@ -1455,6 +1473,12 @@ import type { IntTransactionOpcodeGasServiceListData, IntTransactionOpcodeGasServiceListError, IntTransactionOpcodeGasServiceListResponse, + IntTransactionResourceGasServiceGetData, + IntTransactionResourceGasServiceGetError, + IntTransactionResourceGasServiceGetResponse, + IntTransactionResourceGasServiceListData, + IntTransactionResourceGasServiceListError, + IntTransactionResourceGasServiceListResponse, } from '../types.gen'; export type QueryKey = [ @@ -9120,6 +9144,60 @@ export const intBlockProposerCanonicalServiceGetOptions = (options: Options) => + createQueryKey('intBlockResourceGasServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const intBlockResourceGasServiceListOptions = (options?: Options) => + queryOptions< + IntBlockResourceGasServiceListResponse, + IntBlockResourceGasServiceListError, + IntBlockResourceGasServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intBlockResourceGasServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intBlockResourceGasServiceListQueryKey(options), + }); + +export const intBlockResourceGasServiceGetQueryKey = (options: Options) => + createQueryKey('intBlockResourceGasServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intBlockResourceGasServiceGetOptions = (options: Options) => + queryOptions< + IntBlockResourceGasServiceGetResponse, + IntBlockResourceGasServiceGetError, + IntBlockResourceGasServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intBlockResourceGasServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intBlockResourceGasServiceGetQueryKey(options), + }); + export const intContractCreationServiceListQueryKey = (options?: Options) => createQueryKey('intContractCreationServiceList', options); @@ -11898,6 +11976,66 @@ export const intTransactionCallFrameOpcodeGasServiceGetOptions = ( queryKey: intTransactionCallFrameOpcodeGasServiceGetQueryKey(options), }); +export const intTransactionCallFrameOpcodeResourceGasServiceListQueryKey = ( + options?: Options +) => createQueryKey('intTransactionCallFrameOpcodeResourceGasServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const intTransactionCallFrameOpcodeResourceGasServiceListOptions = ( + options?: Options +) => + queryOptions< + IntTransactionCallFrameOpcodeResourceGasServiceListResponse, + IntTransactionCallFrameOpcodeResourceGasServiceListError, + IntTransactionCallFrameOpcodeResourceGasServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionCallFrameOpcodeResourceGasServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionCallFrameOpcodeResourceGasServiceListQueryKey(options), + }); + +export const intTransactionCallFrameOpcodeResourceGasServiceGetQueryKey = ( + options: Options +) => createQueryKey('intTransactionCallFrameOpcodeResourceGasServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionCallFrameOpcodeResourceGasServiceGetOptions = ( + options: Options +) => + queryOptions< + IntTransactionCallFrameOpcodeResourceGasServiceGetResponse, + IntTransactionCallFrameOpcodeResourceGasServiceGetError, + IntTransactionCallFrameOpcodeResourceGasServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionCallFrameOpcodeResourceGasServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionCallFrameOpcodeResourceGasServiceGetQueryKey(options), + }); + export const intTransactionOpcodeGasServiceListQueryKey = (options?: Options) => createQueryKey('intTransactionOpcodeGasServiceList', options); @@ -11951,3 +12089,61 @@ export const intTransactionOpcodeGasServiceGetOptions = (options: Options +) => createQueryKey('intTransactionResourceGasServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const intTransactionResourceGasServiceListOptions = ( + options?: Options +) => + queryOptions< + IntTransactionResourceGasServiceListResponse, + IntTransactionResourceGasServiceListError, + IntTransactionResourceGasServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionResourceGasServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionResourceGasServiceListQueryKey(options), + }); + +export const intTransactionResourceGasServiceGetQueryKey = ( + options: Options +) => createQueryKey('intTransactionResourceGasServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionResourceGasServiceGetOptions = (options: Options) => + queryOptions< + IntTransactionResourceGasServiceGetResponse, + IntTransactionResourceGasServiceGetError, + IntTransactionResourceGasServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionResourceGasServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionResourceGasServiceGetQueryKey(options), + }); diff --git a/src/api/index.ts b/src/api/index.ts index 2b5fe6a57..ab13d7f6d 100644 --- a/src/api/index.ts +++ b/src/api/index.ts @@ -265,6 +265,8 @@ export { intBlockOpcodeGasServiceList, intBlockProposerCanonicalServiceGet, intBlockProposerCanonicalServiceList, + intBlockResourceGasServiceGet, + intBlockResourceGasServiceList, intContractCreationServiceGet, intContractCreationServiceList, intContractSelfdestructServiceGet, @@ -359,10 +361,14 @@ export { intStorageSlotStateWithExpiryServiceList, intTransactionCallFrameOpcodeGasServiceGet, intTransactionCallFrameOpcodeGasServiceList, + intTransactionCallFrameOpcodeResourceGasServiceGet, + intTransactionCallFrameOpcodeResourceGasServiceList, intTransactionCallFrameServiceGet, intTransactionCallFrameServiceList, intTransactionOpcodeGasServiceGet, intTransactionOpcodeGasServiceList, + intTransactionResourceGasServiceGet, + intTransactionResourceGasServiceList, type Options, } from './sdk.gen'; export type { @@ -1808,6 +1814,7 @@ export type { GetIntBlockMevCanonicalResponse, GetIntBlockOpcodeGasResponse, GetIntBlockProposerCanonicalResponse, + GetIntBlockResourceGasResponse, GetIntContractCreationResponse, GetIntContractSelfdestructResponse, GetIntContractStorageExpiry12mResponse, @@ -1855,8 +1862,10 @@ export type { GetIntStorageSlotStateWithExpiryByBlockResponse, GetIntStorageSlotStateWithExpiryResponse, GetIntTransactionCallFrameOpcodeGasResponse, + GetIntTransactionCallFrameOpcodeResourceGasResponse, GetIntTransactionCallFrameResponse, GetIntTransactionOpcodeGasResponse, + GetIntTransactionResourceGasResponse, GoogleProtobufAny, IntAddressFirstAccess, IntAddressFirstAccessServiceGetData, @@ -2001,6 +2010,17 @@ export type { IntBlockProposerCanonicalServiceListErrors, IntBlockProposerCanonicalServiceListResponse, IntBlockProposerCanonicalServiceListResponses, + IntBlockResourceGas, + IntBlockResourceGasServiceGetData, + IntBlockResourceGasServiceGetError, + IntBlockResourceGasServiceGetErrors, + IntBlockResourceGasServiceGetResponse, + IntBlockResourceGasServiceGetResponses, + IntBlockResourceGasServiceListData, + IntBlockResourceGasServiceListError, + IntBlockResourceGasServiceListErrors, + IntBlockResourceGasServiceListResponse, + IntBlockResourceGasServiceListResponses, IntContractCreation, IntContractCreationServiceGetData, IntContractCreationServiceGetError, @@ -2519,6 +2539,17 @@ export type { IntTransactionCallFrameOpcodeGasServiceListErrors, IntTransactionCallFrameOpcodeGasServiceListResponse, IntTransactionCallFrameOpcodeGasServiceListResponses, + IntTransactionCallFrameOpcodeResourceGas, + IntTransactionCallFrameOpcodeResourceGasServiceGetData, + IntTransactionCallFrameOpcodeResourceGasServiceGetError, + IntTransactionCallFrameOpcodeResourceGasServiceGetErrors, + IntTransactionCallFrameOpcodeResourceGasServiceGetResponse, + IntTransactionCallFrameOpcodeResourceGasServiceGetResponses, + IntTransactionCallFrameOpcodeResourceGasServiceListData, + IntTransactionCallFrameOpcodeResourceGasServiceListError, + IntTransactionCallFrameOpcodeResourceGasServiceListErrors, + IntTransactionCallFrameOpcodeResourceGasServiceListResponse, + IntTransactionCallFrameOpcodeResourceGasServiceListResponses, IntTransactionCallFrameServiceGetData, IntTransactionCallFrameServiceGetError, IntTransactionCallFrameServiceGetErrors, @@ -2540,6 +2571,17 @@ export type { IntTransactionOpcodeGasServiceListErrors, IntTransactionOpcodeGasServiceListResponse, IntTransactionOpcodeGasServiceListResponses, + IntTransactionResourceGas, + IntTransactionResourceGasServiceGetData, + IntTransactionResourceGasServiceGetError, + IntTransactionResourceGasServiceGetErrors, + IntTransactionResourceGasServiceGetResponse, + IntTransactionResourceGasServiceGetResponses, + IntTransactionResourceGasServiceListData, + IntTransactionResourceGasServiceListError, + IntTransactionResourceGasServiceListErrors, + IntTransactionResourceGasServiceListResponse, + IntTransactionResourceGasServiceListResponses, ListAdminCbtIncrementalResponse, ListAdminCbtScheduledResponse, ListDimBlockBlobSubmitterResponse, @@ -2672,6 +2714,7 @@ export type { ListIntBlockMevCanonicalResponse, ListIntBlockOpcodeGasResponse, ListIntBlockProposerCanonicalResponse, + ListIntBlockResourceGasResponse, ListIntContractCreationResponse, ListIntContractSelfdestructResponse, ListIntContractStorageExpiry12mResponse, @@ -2719,7 +2762,9 @@ export type { ListIntStorageSlotStateWithExpiryByBlockResponse, ListIntStorageSlotStateWithExpiryResponse, ListIntTransactionCallFrameOpcodeGasResponse, + ListIntTransactionCallFrameOpcodeResourceGasResponse, ListIntTransactionCallFrameResponse, ListIntTransactionOpcodeGasResponse, + ListIntTransactionResourceGasResponse, Status, } from './types.gen'; diff --git a/src/api/sdk.gen.ts b/src/api/sdk.gen.ts index e9e957f1e..1800f097b 100644 --- a/src/api/sdk.gen.ts +++ b/src/api/sdk.gen.ts @@ -795,6 +795,12 @@ import type { IntBlockProposerCanonicalServiceListData, IntBlockProposerCanonicalServiceListErrors, IntBlockProposerCanonicalServiceListResponses, + IntBlockResourceGasServiceGetData, + IntBlockResourceGasServiceGetErrors, + IntBlockResourceGasServiceGetResponses, + IntBlockResourceGasServiceListData, + IntBlockResourceGasServiceListErrors, + IntBlockResourceGasServiceListResponses, IntContractCreationServiceGetData, IntContractCreationServiceGetErrors, IntContractCreationServiceGetResponses, @@ -1077,6 +1083,12 @@ import type { IntTransactionCallFrameOpcodeGasServiceListData, IntTransactionCallFrameOpcodeGasServiceListErrors, IntTransactionCallFrameOpcodeGasServiceListResponses, + IntTransactionCallFrameOpcodeResourceGasServiceGetData, + IntTransactionCallFrameOpcodeResourceGasServiceGetErrors, + IntTransactionCallFrameOpcodeResourceGasServiceGetResponses, + IntTransactionCallFrameOpcodeResourceGasServiceListData, + IntTransactionCallFrameOpcodeResourceGasServiceListErrors, + IntTransactionCallFrameOpcodeResourceGasServiceListResponses, IntTransactionCallFrameServiceGetData, IntTransactionCallFrameServiceGetErrors, IntTransactionCallFrameServiceGetResponses, @@ -1089,6 +1101,12 @@ import type { IntTransactionOpcodeGasServiceListData, IntTransactionOpcodeGasServiceListErrors, IntTransactionOpcodeGasServiceListResponses, + IntTransactionResourceGasServiceGetData, + IntTransactionResourceGasServiceGetErrors, + IntTransactionResourceGasServiceGetResponses, + IntTransactionResourceGasServiceListData, + IntTransactionResourceGasServiceListErrors, + IntTransactionResourceGasServiceListResponses, } from './types.gen'; import { zAdminCbtIncrementalServiceGetData, @@ -1619,6 +1637,10 @@ import { zIntBlockProposerCanonicalServiceGetResponse, zIntBlockProposerCanonicalServiceListData, zIntBlockProposerCanonicalServiceListResponse, + zIntBlockResourceGasServiceGetData, + zIntBlockResourceGasServiceGetResponse, + zIntBlockResourceGasServiceListData, + zIntBlockResourceGasServiceListResponse, zIntContractCreationServiceGetData, zIntContractCreationServiceGetResponse, zIntContractCreationServiceListData, @@ -1807,6 +1829,10 @@ import { zIntTransactionCallFrameOpcodeGasServiceGetResponse, zIntTransactionCallFrameOpcodeGasServiceListData, zIntTransactionCallFrameOpcodeGasServiceListResponse, + zIntTransactionCallFrameOpcodeResourceGasServiceGetData, + zIntTransactionCallFrameOpcodeResourceGasServiceGetResponse, + zIntTransactionCallFrameOpcodeResourceGasServiceListData, + zIntTransactionCallFrameOpcodeResourceGasServiceListResponse, zIntTransactionCallFrameServiceGetData, zIntTransactionCallFrameServiceGetResponse, zIntTransactionCallFrameServiceListData, @@ -1815,6 +1841,10 @@ import { zIntTransactionOpcodeGasServiceGetResponse, zIntTransactionOpcodeGasServiceListData, zIntTransactionOpcodeGasServiceListResponse, + zIntTransactionResourceGasServiceGetData, + zIntTransactionResourceGasServiceGetResponse, + zIntTransactionResourceGasServiceListData, + zIntTransactionResourceGasServiceListResponse, } from './zod.gen'; export type Options = Options2< @@ -6818,6 +6848,44 @@ export const intBlockProposerCanonicalServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + IntBlockResourceGasServiceListResponses, + IntBlockResourceGasServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntBlockResourceGasServiceListData.parseAsync(data), + responseValidator: async data => await zIntBlockResourceGasServiceListResponse.parseAsync(data), + url: '/api/v1/int_block_resource_gas', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intBlockResourceGasServiceGet = ( + options: Options +) => + (options.client ?? client).get< + IntBlockResourceGasServiceGetResponses, + IntBlockResourceGasServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntBlockResourceGasServiceGetData.parseAsync(data), + responseValidator: async data => await zIntBlockResourceGasServiceGetResponse.parseAsync(data), + url: '/api/v1/int_block_resource_gas/{block_number}', + ...options, + }); + /** * List records * @@ -8639,6 +8707,45 @@ export const intTransactionCallFrameOpcodeGasServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + IntTransactionCallFrameOpcodeResourceGasServiceListResponses, + IntTransactionCallFrameOpcodeResourceGasServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionCallFrameOpcodeResourceGasServiceListData.parseAsync(data), + responseValidator: async data => + await zIntTransactionCallFrameOpcodeResourceGasServiceListResponse.parseAsync(data), + url: '/api/v1/int_transaction_call_frame_opcode_resource_gas', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionCallFrameOpcodeResourceGasServiceGet = ( + options: Options +) => + (options.client ?? client).get< + IntTransactionCallFrameOpcodeResourceGasServiceGetResponses, + IntTransactionCallFrameOpcodeResourceGasServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionCallFrameOpcodeResourceGasServiceGetData.parseAsync(data), + responseValidator: async data => await zIntTransactionCallFrameOpcodeResourceGasServiceGetResponse.parseAsync(data), + url: '/api/v1/int_transaction_call_frame_opcode_resource_gas/{block_number}', + ...options, + }); + /** * List records * @@ -8676,3 +8783,41 @@ export const intTransactionOpcodeGasServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + IntTransactionResourceGasServiceListResponses, + IntTransactionResourceGasServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionResourceGasServiceListData.parseAsync(data), + responseValidator: async data => await zIntTransactionResourceGasServiceListResponse.parseAsync(data), + url: '/api/v1/int_transaction_resource_gas', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionResourceGasServiceGet = ( + options: Options +) => + (options.client ?? client).get< + IntTransactionResourceGasServiceGetResponses, + IntTransactionResourceGasServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionResourceGasServiceGetData.parseAsync(data), + responseValidator: async data => await zIntTransactionResourceGasServiceGetResponse.parseAsync(data), + url: '/api/v1/int_transaction_resource_gas/{block_number}', + ...options, + }); diff --git a/src/api/types.gen.ts b/src/api/types.gen.ts index 3e5dcd1aa..6a1703be5 100644 --- a/src/api/types.gen.ts +++ b/src/api/types.gen.ts @@ -6659,6 +6659,13 @@ export type GetIntBlockProposerCanonicalResponse = { item?: IntBlockProposerCanonical; }; +/** + * Response for getting a single int_block_resource_gas record + */ +export type GetIntBlockResourceGasResponse = { + item?: IntBlockResourceGas; +}; + /** * Response for getting a single int_contract_creation record */ @@ -6988,6 +6995,13 @@ export type GetIntTransactionCallFrameOpcodeGasResponse = { item?: IntTransactionCallFrameOpcodeGas; }; +/** + * Response for getting a single int_transaction_call_frame_opcode_resource_gas record + */ +export type GetIntTransactionCallFrameOpcodeResourceGasResponse = { + item?: IntTransactionCallFrameOpcodeResourceGas; +}; + /** * Response for getting a single int_transaction_call_frame record */ @@ -7002,6 +7016,13 @@ export type GetIntTransactionOpcodeGasResponse = { item?: IntTransactionOpcodeGas; }; +/** + * Response for getting a single int_transaction_resource_gas record + */ +export type GetIntTransactionResourceGasResponse = { + item?: IntTransactionResourceGas; +}; + /** * Contains an arbitrary serialized message along with a @type that describes the type of the serialized message. */ @@ -7620,6 +7641,53 @@ export type IntBlockProposerCanonical = { updated_date_time?: number; }; +export type IntBlockResourceGas = { + /** + * The block number + */ + block_number?: number; + /** + * Total cold address/storage access gas across all transactions + */ + gas_address_access?: number; + /** + * Total block size gas across all transactions + */ + gas_block_size?: number; + /** + * Total bloom filter topic gas across all transactions + */ + gas_bloom_topics?: number; + /** + * Total compute gas across all transactions + */ + gas_compute?: number; + /** + * Total history/log data gas across all transactions + */ + gas_history?: number; + /** + * Total memory expansion gas across all transactions + */ + gas_memory?: number; + /** + * Total gas refund across all transactions + */ + gas_refund?: number; + /** + * Total state growth gas across all transactions + */ + gas_state_growth?: number; + /** + * The name of the network + */ + meta_network_name?: string; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + export type IntContractCreation = { /** * Block where contract was created @@ -9542,6 +9610,10 @@ export type IntTransactionCallFrameOpcodeGas = { * Sequential frame ID within transaction (0 = root) */ call_frame_id?: number; + /** + * Number of cold storage/account accesses (EIP-2929). + */ + cold_access_count?: number; /** * Number of times this opcode was executed in this frame */ @@ -9558,6 +9630,93 @@ export type IntTransactionCallFrameOpcodeGas = { * For CALL opcodes: includes all descendant frame gas. For others: same as gas */ gas_cumulative?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. + */ + memory_expansion_gas?: number; + /** + * SUM(words_after²). + */ + memory_words_sq_sum_after?: number; + /** + * SUM(words_before²). + */ + memory_words_sq_sum_before?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. + */ + memory_words_sum_after?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. + */ + memory_words_sum_before?: number; + /** + * The name of the network + */ + meta_network_name?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) + */ + opcode?: string; + /** + * The transaction hash (hex encoded with 0x prefix) + */ + transaction_hash?: string; + /** + * The index of the transaction within the block + */ + transaction_index?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + +export type IntTransactionCallFrameOpcodeResourceGas = { + /** + * The block number containing the transaction + */ + block_number?: number; + /** + * Sequential frame ID within transaction (0 = root) + */ + call_frame_id?: number; + /** + * Number of times this opcode was executed in this frame + */ + count?: number; + /** + * Total gas consumed by this opcode in this frame + */ + gas?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) + */ + gas_address_access?: number; + /** + * Gas attributed to block size (always 0 at opcode level) + */ + gas_block_size?: number; + /** + * Gas attributed to bloom filter topic indexing + */ + gas_bloom_topics?: number; + /** + * Gas attributed to pure computation + */ + gas_compute?: number; + /** + * Gas attributed to history/log data storage + */ + gas_history?: number; + /** + * Gas attributed to memory expansion + */ + gas_memory?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) + */ + gas_state_growth?: number; /** * The name of the network */ @@ -9623,6 +9782,61 @@ export type IntTransactionOpcodeGas = { updated_date_time?: number; }; +export type IntTransactionResourceGas = { + /** + * The block number containing the transaction + */ + block_number?: number; + /** + * Total cold address/storage access gas + */ + gas_address_access?: number; + /** + * Total block size gas (from intrinsic calldata) + */ + gas_block_size?: number; + /** + * Total bloom filter topic gas + */ + gas_bloom_topics?: number; + /** + * Total compute gas (EVM execution + intrinsic compute) + */ + gas_compute?: number; + /** + * Total history/log data gas + */ + gas_history?: number; + /** + * Total memory expansion gas + */ + gas_memory?: number; + /** + * Gas refund from SSTORE operations + */ + gas_refund?: number; + /** + * Total state growth gas + */ + gas_state_growth?: number; + /** + * The name of the network + */ + meta_network_name?: string; + /** + * The transaction hash (hex encoded with 0x prefix) + */ + transaction_hash?: string; + /** + * The index of the transaction within the block + */ + transaction_index?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + /** * Response for listing admin_cbt_incremental records */ @@ -11471,6 +11685,20 @@ export type ListIntBlockProposerCanonicalResponse = { next_page_token?: string; }; +/** + * Response for listing int_block_resource_gas records + */ +export type ListIntBlockResourceGasResponse = { + /** + * The list of int_block_resource_gas. + */ + int_block_resource_gas?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + /** * Response for listing int_contract_creation records */ @@ -12129,6 +12357,20 @@ export type ListIntTransactionCallFrameOpcodeGasResponse = { next_page_token?: string; }; +/** + * Response for listing int_transaction_call_frame_opcode_resource_gas records + */ +export type ListIntTransactionCallFrameOpcodeResourceGasResponse = { + /** + * The list of int_transaction_call_frame_opcode_resource_gas. + */ + int_transaction_call_frame_opcode_resource_gas?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + /** * Response for listing int_transaction_call_frame records */ @@ -12157,6 +12399,20 @@ export type ListIntTransactionOpcodeGasResponse = { next_page_token?: string; }; +/** + * Response for listing int_transaction_resource_gas records + */ +export type ListIntTransactionResourceGasResponse = { + /** + * The list of int_transaction_resource_gas. + */ + int_transaction_resource_gas?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + /** * The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors). */ @@ -72287,122 +72543,630 @@ export type IntBlockProposerCanonicalServiceGetResponses = { export type IntBlockProposerCanonicalServiceGetResponse = IntBlockProposerCanonicalServiceGetResponses[keyof IntBlockProposerCanonicalServiceGetResponses]; -export type IntContractCreationServiceListData = { +export type IntBlockResourceGasServiceListData = { body?: never; path?: never; query?: { /** - * Block where contract was created (filter: eq) + * The block number (filter: eq) */ block_number_eq?: number; /** - * Block where contract was created (filter: ne) + * The block number (filter: ne) */ block_number_ne?: number; /** - * Block where contract was created (filter: lt) + * The block number (filter: lt) */ block_number_lt?: number; /** - * Block where contract was created (filter: lte) + * The block number (filter: lte) */ block_number_lte?: number; /** - * Block where contract was created (filter: gt) + * The block number (filter: gt) */ block_number_gt?: number; /** - * Block where contract was created (filter: gte) + * The block number (filter: gte) */ block_number_gte?: number; /** - * Block where contract was created (filter: between_min) + * The block number (filter: between_min) */ block_number_between_min?: number; /** - * Block where contract was created (filter: between_max_value) + * The block number (filter: between_max_value) */ block_number_between_max_value?: number; /** - * Block where contract was created (filter: in_values) (comma-separated list) + * The block number (filter: in_values) (comma-separated list) */ block_number_in_values?: string; /** - * Block where contract was created (filter: not_in_values) (comma-separated list) + * The block number (filter: not_in_values) (comma-separated list) */ block_number_not_in_values?: string; /** - * Address of created contract (filter: eq) - */ - contract_address_eq?: string; - /** - * Address of created contract (filter: ne) - */ - contract_address_ne?: string; - /** - * Address of created contract (filter: contains) - */ - contract_address_contains?: string; - /** - * Address of created contract (filter: starts_with) - */ - contract_address_starts_with?: string; - /** - * Address of created contract (filter: ends_with) - */ - contract_address_ends_with?: string; - /** - * Address of created contract (filter: like) - */ - contract_address_like?: string; - /** - * Address of created contract (filter: not_like) - */ - contract_address_not_like?: string; - /** - * Address of created contract (filter: in_values) (comma-separated list) - */ - contract_address_in_values?: string; - /** - * Address of created contract (filter: not_in_values) (comma-separated list) - */ - contract_address_not_in_values?: string; - /** - * Transaction hash (filter: eq) + * The name of the network (filter: eq) */ - transaction_hash_eq?: string; + meta_network_name_eq?: string; /** - * Transaction hash (filter: ne) + * The name of the network (filter: ne) */ - transaction_hash_ne?: string; + meta_network_name_ne?: string; /** - * Transaction hash (filter: contains) + * The name of the network (filter: contains) */ - transaction_hash_contains?: string; + meta_network_name_contains?: string; /** - * Transaction hash (filter: starts_with) + * The name of the network (filter: starts_with) */ - transaction_hash_starts_with?: string; + meta_network_name_starts_with?: string; /** - * Transaction hash (filter: ends_with) + * The name of the network (filter: ends_with) */ - transaction_hash_ends_with?: string; + meta_network_name_ends_with?: string; /** - * Transaction hash (filter: like) + * The name of the network (filter: like) */ - transaction_hash_like?: string; + meta_network_name_like?: string; /** - * Transaction hash (filter: not_like) + * The name of the network (filter: not_like) */ - transaction_hash_not_like?: string; + meta_network_name_not_like?: string; /** - * Transaction hash (filter: in_values) (comma-separated list) + * The name of the network (filter: in_values) (comma-separated list) */ - transaction_hash_in_values?: string; + meta_network_name_in_values?: string; /** - * Transaction hash (filter: not_in_values) (comma-separated list) + * The name of the network (filter: not_in_values) (comma-separated list) */ - transaction_hash_not_in_values?: string; + meta_network_name_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * Total compute gas across all transactions (filter: eq) + */ + gas_compute_eq?: number; + /** + * Total compute gas across all transactions (filter: ne) + */ + gas_compute_ne?: number; + /** + * Total compute gas across all transactions (filter: lt) + */ + gas_compute_lt?: number; + /** + * Total compute gas across all transactions (filter: lte) + */ + gas_compute_lte?: number; + /** + * Total compute gas across all transactions (filter: gt) + */ + gas_compute_gt?: number; + /** + * Total compute gas across all transactions (filter: gte) + */ + gas_compute_gte?: number; + /** + * Total compute gas across all transactions (filter: between_min) + */ + gas_compute_between_min?: number; + /** + * Total compute gas across all transactions (filter: between_max_value) + */ + gas_compute_between_max_value?: number; + /** + * Total compute gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_compute_in_values?: string; + /** + * Total compute gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_compute_not_in_values?: string; + /** + * Total memory expansion gas across all transactions (filter: eq) + */ + gas_memory_eq?: number; + /** + * Total memory expansion gas across all transactions (filter: ne) + */ + gas_memory_ne?: number; + /** + * Total memory expansion gas across all transactions (filter: lt) + */ + gas_memory_lt?: number; + /** + * Total memory expansion gas across all transactions (filter: lte) + */ + gas_memory_lte?: number; + /** + * Total memory expansion gas across all transactions (filter: gt) + */ + gas_memory_gt?: number; + /** + * Total memory expansion gas across all transactions (filter: gte) + */ + gas_memory_gte?: number; + /** + * Total memory expansion gas across all transactions (filter: between_min) + */ + gas_memory_between_min?: number; + /** + * Total memory expansion gas across all transactions (filter: between_max_value) + */ + gas_memory_between_max_value?: number; + /** + * Total memory expansion gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_memory_in_values?: string; + /** + * Total memory expansion gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_memory_not_in_values?: string; + /** + * Total cold address/storage access gas across all transactions (filter: eq) + */ + gas_address_access_eq?: number; + /** + * Total cold address/storage access gas across all transactions (filter: ne) + */ + gas_address_access_ne?: number; + /** + * Total cold address/storage access gas across all transactions (filter: lt) + */ + gas_address_access_lt?: number; + /** + * Total cold address/storage access gas across all transactions (filter: lte) + */ + gas_address_access_lte?: number; + /** + * Total cold address/storage access gas across all transactions (filter: gt) + */ + gas_address_access_gt?: number; + /** + * Total cold address/storage access gas across all transactions (filter: gte) + */ + gas_address_access_gte?: number; + /** + * Total cold address/storage access gas across all transactions (filter: between_min) + */ + gas_address_access_between_min?: number; + /** + * Total cold address/storage access gas across all transactions (filter: between_max_value) + */ + gas_address_access_between_max_value?: number; + /** + * Total cold address/storage access gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_address_access_in_values?: string; + /** + * Total cold address/storage access gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_address_access_not_in_values?: string; + /** + * Total state growth gas across all transactions (filter: eq) + */ + gas_state_growth_eq?: number; + /** + * Total state growth gas across all transactions (filter: ne) + */ + gas_state_growth_ne?: number; + /** + * Total state growth gas across all transactions (filter: lt) + */ + gas_state_growth_lt?: number; + /** + * Total state growth gas across all transactions (filter: lte) + */ + gas_state_growth_lte?: number; + /** + * Total state growth gas across all transactions (filter: gt) + */ + gas_state_growth_gt?: number; + /** + * Total state growth gas across all transactions (filter: gte) + */ + gas_state_growth_gte?: number; + /** + * Total state growth gas across all transactions (filter: between_min) + */ + gas_state_growth_between_min?: number; + /** + * Total state growth gas across all transactions (filter: between_max_value) + */ + gas_state_growth_between_max_value?: number; + /** + * Total state growth gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_state_growth_in_values?: string; + /** + * Total state growth gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_state_growth_not_in_values?: string; + /** + * Total history/log data gas across all transactions (filter: eq) + */ + gas_history_eq?: number; + /** + * Total history/log data gas across all transactions (filter: ne) + */ + gas_history_ne?: number; + /** + * Total history/log data gas across all transactions (filter: lt) + */ + gas_history_lt?: number; + /** + * Total history/log data gas across all transactions (filter: lte) + */ + gas_history_lte?: number; + /** + * Total history/log data gas across all transactions (filter: gt) + */ + gas_history_gt?: number; + /** + * Total history/log data gas across all transactions (filter: gte) + */ + gas_history_gte?: number; + /** + * Total history/log data gas across all transactions (filter: between_min) + */ + gas_history_between_min?: number; + /** + * Total history/log data gas across all transactions (filter: between_max_value) + */ + gas_history_between_max_value?: number; + /** + * Total history/log data gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_history_in_values?: string; + /** + * Total history/log data gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_history_not_in_values?: string; + /** + * Total bloom filter topic gas across all transactions (filter: eq) + */ + gas_bloom_topics_eq?: number; + /** + * Total bloom filter topic gas across all transactions (filter: ne) + */ + gas_bloom_topics_ne?: number; + /** + * Total bloom filter topic gas across all transactions (filter: lt) + */ + gas_bloom_topics_lt?: number; + /** + * Total bloom filter topic gas across all transactions (filter: lte) + */ + gas_bloom_topics_lte?: number; + /** + * Total bloom filter topic gas across all transactions (filter: gt) + */ + gas_bloom_topics_gt?: number; + /** + * Total bloom filter topic gas across all transactions (filter: gte) + */ + gas_bloom_topics_gte?: number; + /** + * Total bloom filter topic gas across all transactions (filter: between_min) + */ + gas_bloom_topics_between_min?: number; + /** + * Total bloom filter topic gas across all transactions (filter: between_max_value) + */ + gas_bloom_topics_between_max_value?: number; + /** + * Total bloom filter topic gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_bloom_topics_in_values?: string; + /** + * Total bloom filter topic gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_bloom_topics_not_in_values?: string; + /** + * Total block size gas across all transactions (filter: eq) + */ + gas_block_size_eq?: number; + /** + * Total block size gas across all transactions (filter: ne) + */ + gas_block_size_ne?: number; + /** + * Total block size gas across all transactions (filter: lt) + */ + gas_block_size_lt?: number; + /** + * Total block size gas across all transactions (filter: lte) + */ + gas_block_size_lte?: number; + /** + * Total block size gas across all transactions (filter: gt) + */ + gas_block_size_gt?: number; + /** + * Total block size gas across all transactions (filter: gte) + */ + gas_block_size_gte?: number; + /** + * Total block size gas across all transactions (filter: between_min) + */ + gas_block_size_between_min?: number; + /** + * Total block size gas across all transactions (filter: between_max_value) + */ + gas_block_size_between_max_value?: number; + /** + * Total block size gas across all transactions (filter: in_values) (comma-separated list) + */ + gas_block_size_in_values?: string; + /** + * Total block size gas across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_block_size_not_in_values?: string; + /** + * Total gas refund across all transactions (filter: eq) + */ + gas_refund_eq?: number; + /** + * Total gas refund across all transactions (filter: ne) + */ + gas_refund_ne?: number; + /** + * Total gas refund across all transactions (filter: lt) + */ + gas_refund_lt?: number; + /** + * Total gas refund across all transactions (filter: lte) + */ + gas_refund_lte?: number; + /** + * Total gas refund across all transactions (filter: gt) + */ + gas_refund_gt?: number; + /** + * Total gas refund across all transactions (filter: gte) + */ + gas_refund_gte?: number; + /** + * Total gas refund across all transactions (filter: between_min) + */ + gas_refund_between_min?: number; + /** + * Total gas refund across all transactions (filter: between_max_value) + */ + gas_refund_between_max_value?: number; + /** + * Total gas refund across all transactions (filter: in_values) (comma-separated list) + */ + gas_refund_in_values?: string; + /** + * Total gas refund across all transactions (filter: not_in_values) (comma-separated list) + */ + gas_refund_not_in_values?: string; + /** + * The maximum number of int_block_resource_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListIntBlockResourceGas` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/int_block_resource_gas'; +}; + +export type IntBlockResourceGasServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntBlockResourceGasServiceListError = + IntBlockResourceGasServiceListErrors[keyof IntBlockResourceGasServiceListErrors]; + +export type IntBlockResourceGasServiceListResponses = { + /** + * OK + */ + 200: ListIntBlockResourceGasResponse; +}; + +export type IntBlockResourceGasServiceListResponse = + IntBlockResourceGasServiceListResponses[keyof IntBlockResourceGasServiceListResponses]; + +export type IntBlockResourceGasServiceGetData = { + body?: never; + path: { + /** + * The block number + */ + block_number: number; + }; + query?: never; + url: '/api/v1/int_block_resource_gas/{block_number}'; +}; + +export type IntBlockResourceGasServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntBlockResourceGasServiceGetError = + IntBlockResourceGasServiceGetErrors[keyof IntBlockResourceGasServiceGetErrors]; + +export type IntBlockResourceGasServiceGetResponses = { + /** + * OK + */ + 200: GetIntBlockResourceGasResponse; +}; + +export type IntBlockResourceGasServiceGetResponse = + IntBlockResourceGasServiceGetResponses[keyof IntBlockResourceGasServiceGetResponses]; + +export type IntContractCreationServiceListData = { + body?: never; + path?: never; + query?: { + /** + * Block where contract was created (filter: eq) + */ + block_number_eq?: number; + /** + * Block where contract was created (filter: ne) + */ + block_number_ne?: number; + /** + * Block where contract was created (filter: lt) + */ + block_number_lt?: number; + /** + * Block where contract was created (filter: lte) + */ + block_number_lte?: number; + /** + * Block where contract was created (filter: gt) + */ + block_number_gt?: number; + /** + * Block where contract was created (filter: gte) + */ + block_number_gte?: number; + /** + * Block where contract was created (filter: between_min) + */ + block_number_between_min?: number; + /** + * Block where contract was created (filter: between_max_value) + */ + block_number_between_max_value?: number; + /** + * Block where contract was created (filter: in_values) (comma-separated list) + */ + block_number_in_values?: string; + /** + * Block where contract was created (filter: not_in_values) (comma-separated list) + */ + block_number_not_in_values?: string; + /** + * Address of created contract (filter: eq) + */ + contract_address_eq?: string; + /** + * Address of created contract (filter: ne) + */ + contract_address_ne?: string; + /** + * Address of created contract (filter: contains) + */ + contract_address_contains?: string; + /** + * Address of created contract (filter: starts_with) + */ + contract_address_starts_with?: string; + /** + * Address of created contract (filter: ends_with) + */ + contract_address_ends_with?: string; + /** + * Address of created contract (filter: like) + */ + contract_address_like?: string; + /** + * Address of created contract (filter: not_like) + */ + contract_address_not_like?: string; + /** + * Address of created contract (filter: in_values) (comma-separated list) + */ + contract_address_in_values?: string; + /** + * Address of created contract (filter: not_in_values) (comma-separated list) + */ + contract_address_not_in_values?: string; + /** + * Transaction hash (filter: eq) + */ + transaction_hash_eq?: string; + /** + * Transaction hash (filter: ne) + */ + transaction_hash_ne?: string; + /** + * Transaction hash (filter: contains) + */ + transaction_hash_contains?: string; + /** + * Transaction hash (filter: starts_with) + */ + transaction_hash_starts_with?: string; + /** + * Transaction hash (filter: ends_with) + */ + transaction_hash_ends_with?: string; + /** + * Transaction hash (filter: like) + */ + transaction_hash_like?: string; + /** + * Transaction hash (filter: not_like) + */ + transaction_hash_not_like?: string; + /** + * Transaction hash (filter: in_values) (comma-separated list) + */ + transaction_hash_in_values?: string; + /** + * Transaction hash (filter: not_in_values) (comma-separated list) + */ + transaction_hash_not_in_values?: string; /** * Timestamp when the record was last updated (filter: eq) */ @@ -92494,83 +93258,1483 @@ export type IntTransactionCallFrameOpcodeGasServiceListData = { */ transaction_index_not_in_values?: string; /** - * Number of times this opcode was executed in this frame (filter: eq) + * Number of times this opcode was executed in this frame (filter: eq) + */ + count_eq?: number; + /** + * Number of times this opcode was executed in this frame (filter: ne) + */ + count_ne?: number; + /** + * Number of times this opcode was executed in this frame (filter: lt) + */ + count_lt?: number; + /** + * Number of times this opcode was executed in this frame (filter: lte) + */ + count_lte?: number; + /** + * Number of times this opcode was executed in this frame (filter: gt) + */ + count_gt?: number; + /** + * Number of times this opcode was executed in this frame (filter: gte) + */ + count_gte?: number; + /** + * Number of times this opcode was executed in this frame (filter: between_min) + */ + count_between_min?: number; + /** + * Number of times this opcode was executed in this frame (filter: between_max_value) + */ + count_between_max_value?: number; + /** + * Number of times this opcode was executed in this frame (filter: in_values) (comma-separated list) + */ + count_in_values?: string; + /** + * Number of times this opcode was executed in this frame (filter: not_in_values) (comma-separated list) + */ + count_not_in_values?: string; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: eq) + */ + gas_eq?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: ne) + */ + gas_ne?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: lt) + */ + gas_lt?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: lte) + */ + gas_lte?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: gt) + */ + gas_gt?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: gte) + */ + gas_gte?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: between_min) + */ + gas_between_min?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: between_max_value) + */ + gas_between_max_value?: number; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: in_values) (comma-separated list) + */ + gas_in_values?: string; + /** + * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: not_in_values) (comma-separated list) + */ + gas_not_in_values?: string; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: eq) + */ + gas_cumulative_eq?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: ne) + */ + gas_cumulative_ne?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: lt) + */ + gas_cumulative_lt?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: lte) + */ + gas_cumulative_lte?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: gt) + */ + gas_cumulative_gt?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: gte) + */ + gas_cumulative_gte?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: between_min) + */ + gas_cumulative_between_min?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: between_max_value) + */ + gas_cumulative_between_max_value?: number; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: in_values) (comma-separated list) + */ + gas_cumulative_in_values?: string; + /** + * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: not_in_values) (comma-separated list) + */ + gas_cumulative_not_in_values?: string; + /** + * Number of times this opcode resulted in an error in this frame (filter: eq) + */ + error_count_eq?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: ne) + */ + error_count_ne?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: lt) + */ + error_count_lt?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: lte) + */ + error_count_lte?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: gt) + */ + error_count_gt?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: gte) + */ + error_count_gte?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: between_min) + */ + error_count_between_min?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: between_max_value) + */ + error_count_between_max_value?: number; + /** + * Number of times this opcode resulted in an error in this frame (filter: in_values) (comma-separated list) + */ + error_count_in_values?: string; + /** + * Number of times this opcode resulted in an error in this frame (filter: not_in_values) (comma-separated list) + */ + error_count_not_in_values?: string; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: eq) + */ + memory_words_sum_before_eq?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: ne) + */ + memory_words_sum_before_ne?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: lt) + */ + memory_words_sum_before_lt?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: lte) + */ + memory_words_sum_before_lte?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: gt) + */ + memory_words_sum_before_gt?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: gte) + */ + memory_words_sum_before_gte?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: between_min) + */ + memory_words_sum_before_between_min?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: between_max_value) + */ + memory_words_sum_before_between_max_value?: number; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: in_values) (comma-separated list) + */ + memory_words_sum_before_in_values?: string; + /** + * SUM(ceil(memory_bytes/32)) before each opcode executes. (filter: not_in_values) (comma-separated list) + */ + memory_words_sum_before_not_in_values?: string; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: eq) + */ + memory_words_sum_after_eq?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: ne) + */ + memory_words_sum_after_ne?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: lt) + */ + memory_words_sum_after_lt?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: lte) + */ + memory_words_sum_after_lte?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: gt) + */ + memory_words_sum_after_gt?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: gte) + */ + memory_words_sum_after_gte?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: between_min) + */ + memory_words_sum_after_between_min?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: between_max_value) + */ + memory_words_sum_after_between_max_value?: number; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: in_values) (comma-separated list) + */ + memory_words_sum_after_in_values?: string; + /** + * SUM(ceil(memory_bytes/32)) after each opcode executes. (filter: not_in_values) (comma-separated list) + */ + memory_words_sum_after_not_in_values?: string; + /** + * SUM(words_before²). (filter: eq) + */ + memory_words_sq_sum_before_eq?: number; + /** + * SUM(words_before²). (filter: ne) + */ + memory_words_sq_sum_before_ne?: number; + /** + * SUM(words_before²). (filter: lt) + */ + memory_words_sq_sum_before_lt?: number; + /** + * SUM(words_before²). (filter: lte) + */ + memory_words_sq_sum_before_lte?: number; + /** + * SUM(words_before²). (filter: gt) + */ + memory_words_sq_sum_before_gt?: number; + /** + * SUM(words_before²). (filter: gte) + */ + memory_words_sq_sum_before_gte?: number; + /** + * SUM(words_before²). (filter: between_min) + */ + memory_words_sq_sum_before_between_min?: number; + /** + * SUM(words_before²). (filter: between_max_value) + */ + memory_words_sq_sum_before_between_max_value?: number; + /** + * SUM(words_before²). (filter: in_values) (comma-separated list) + */ + memory_words_sq_sum_before_in_values?: string; + /** + * SUM(words_before²). (filter: not_in_values) (comma-separated list) + */ + memory_words_sq_sum_before_not_in_values?: string; + /** + * SUM(words_after²). (filter: eq) + */ + memory_words_sq_sum_after_eq?: number; + /** + * SUM(words_after²). (filter: ne) + */ + memory_words_sq_sum_after_ne?: number; + /** + * SUM(words_after²). (filter: lt) + */ + memory_words_sq_sum_after_lt?: number; + /** + * SUM(words_after²). (filter: lte) + */ + memory_words_sq_sum_after_lte?: number; + /** + * SUM(words_after²). (filter: gt) + */ + memory_words_sq_sum_after_gt?: number; + /** + * SUM(words_after²). (filter: gte) + */ + memory_words_sq_sum_after_gte?: number; + /** + * SUM(words_after²). (filter: between_min) + */ + memory_words_sq_sum_after_between_min?: number; + /** + * SUM(words_after²). (filter: between_max_value) + */ + memory_words_sq_sum_after_between_max_value?: number; + /** + * SUM(words_after²). (filter: in_values) (comma-separated list) + */ + memory_words_sq_sum_after_in_values?: string; + /** + * SUM(words_after²). (filter: not_in_values) (comma-separated list) + */ + memory_words_sq_sum_after_not_in_values?: string; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: eq) + */ + memory_expansion_gas_eq?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: ne) + */ + memory_expansion_gas_ne?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: lt) + */ + memory_expansion_gas_lt?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: lte) + */ + memory_expansion_gas_lte?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: gt) + */ + memory_expansion_gas_gt?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: gte) + */ + memory_expansion_gas_gte?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: between_min) + */ + memory_expansion_gas_between_min?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: between_max_value) + */ + memory_expansion_gas_between_max_value?: number; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: in_values) (comma-separated list) + */ + memory_expansion_gas_in_values?: string; + /** + * SUM(memory_expansion_gas). Exact per-opcode memory expansion cost. (filter: not_in_values) (comma-separated list) + */ + memory_expansion_gas_not_in_values?: string; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: eq) + */ + cold_access_count_eq?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: ne) + */ + cold_access_count_ne?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: lt) + */ + cold_access_count_lt?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: lte) + */ + cold_access_count_lte?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: gt) + */ + cold_access_count_gt?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: gte) + */ + cold_access_count_gte?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: between_min) + */ + cold_access_count_between_min?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: between_max_value) + */ + cold_access_count_between_max_value?: number; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: in_values) (comma-separated list) + */ + cold_access_count_in_values?: string; + /** + * Number of cold storage/account accesses (EIP-2929). (filter: not_in_values) (comma-separated list) + */ + cold_access_count_not_in_values?: string; + /** + * The maximum number of int_transaction_call_frame_opcode_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListIntTransactionCallFrameOpcodeGas` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/int_transaction_call_frame_opcode_gas'; +}; + +export type IntTransactionCallFrameOpcodeGasServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionCallFrameOpcodeGasServiceListError = + IntTransactionCallFrameOpcodeGasServiceListErrors[keyof IntTransactionCallFrameOpcodeGasServiceListErrors]; + +export type IntTransactionCallFrameOpcodeGasServiceListResponses = { + /** + * OK + */ + 200: ListIntTransactionCallFrameOpcodeGasResponse; +}; + +export type IntTransactionCallFrameOpcodeGasServiceListResponse = + IntTransactionCallFrameOpcodeGasServiceListResponses[keyof IntTransactionCallFrameOpcodeGasServiceListResponses]; + +export type IntTransactionCallFrameOpcodeGasServiceGetData = { + body?: never; + path: { + /** + * The block number containing the transaction + */ + block_number: number; + }; + query?: never; + url: '/api/v1/int_transaction_call_frame_opcode_gas/{block_number}'; +}; + +export type IntTransactionCallFrameOpcodeGasServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionCallFrameOpcodeGasServiceGetError = + IntTransactionCallFrameOpcodeGasServiceGetErrors[keyof IntTransactionCallFrameOpcodeGasServiceGetErrors]; + +export type IntTransactionCallFrameOpcodeGasServiceGetResponses = { + /** + * OK + */ + 200: GetIntTransactionCallFrameOpcodeGasResponse; +}; + +export type IntTransactionCallFrameOpcodeGasServiceGetResponse = + IntTransactionCallFrameOpcodeGasServiceGetResponses[keyof IntTransactionCallFrameOpcodeGasServiceGetResponses]; + +export type IntTransactionCallFrameOpcodeResourceGasServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The block number containing the transaction (filter: eq) + */ + block_number_eq?: number; + /** + * The block number containing the transaction (filter: ne) + */ + block_number_ne?: number; + /** + * The block number containing the transaction (filter: lt) + */ + block_number_lt?: number; + /** + * The block number containing the transaction (filter: lte) + */ + block_number_lte?: number; + /** + * The block number containing the transaction (filter: gt) + */ + block_number_gt?: number; + /** + * The block number containing the transaction (filter: gte) + */ + block_number_gte?: number; + /** + * The block number containing the transaction (filter: between_min) + */ + block_number_between_min?: number; + /** + * The block number containing the transaction (filter: between_max_value) + */ + block_number_between_max_value?: number; + /** + * The block number containing the transaction (filter: in_values) (comma-separated list) + */ + block_number_in_values?: string; + /** + * The block number containing the transaction (filter: not_in_values) (comma-separated list) + */ + block_number_not_in_values?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: eq) + */ + transaction_hash_eq?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: ne) + */ + transaction_hash_ne?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: contains) + */ + transaction_hash_contains?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: starts_with) + */ + transaction_hash_starts_with?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: ends_with) + */ + transaction_hash_ends_with?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: like) + */ + transaction_hash_like?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: not_like) + */ + transaction_hash_not_like?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: in_values) (comma-separated list) + */ + transaction_hash_in_values?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: not_in_values) (comma-separated list) + */ + transaction_hash_not_in_values?: string; + /** + * Sequential frame ID within transaction (0 = root) (filter: eq) + */ + call_frame_id_eq?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: ne) + */ + call_frame_id_ne?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: lt) + */ + call_frame_id_lt?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: lte) + */ + call_frame_id_lte?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: gt) + */ + call_frame_id_gt?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: gte) + */ + call_frame_id_gte?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: between_min) + */ + call_frame_id_between_min?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: between_max_value) + */ + call_frame_id_between_max_value?: number; + /** + * Sequential frame ID within transaction (0 = root) (filter: in_values) (comma-separated list) + */ + call_frame_id_in_values?: string; + /** + * Sequential frame ID within transaction (0 = root) (filter: not_in_values) (comma-separated list) + */ + call_frame_id_not_in_values?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: eq) + */ + opcode_eq?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ne) + */ + opcode_ne?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: contains) + */ + opcode_contains?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: starts_with) + */ + opcode_starts_with?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ends_with) + */ + opcode_ends_with?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: like) + */ + opcode_like?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_like) + */ + opcode_not_like?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: in_values) (comma-separated list) + */ + opcode_in_values?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_in_values) (comma-separated list) + */ + opcode_not_in_values?: string; + /** + * The name of the network (filter: eq) + */ + meta_network_name_eq?: string; + /** + * The name of the network (filter: ne) + */ + meta_network_name_ne?: string; + /** + * The name of the network (filter: contains) + */ + meta_network_name_contains?: string; + /** + * The name of the network (filter: starts_with) + */ + meta_network_name_starts_with?: string; + /** + * The name of the network (filter: ends_with) + */ + meta_network_name_ends_with?: string; + /** + * The name of the network (filter: like) + */ + meta_network_name_like?: string; + /** + * The name of the network (filter: not_like) + */ + meta_network_name_not_like?: string; + /** + * The name of the network (filter: in_values) (comma-separated list) + */ + meta_network_name_in_values?: string; + /** + * The name of the network (filter: not_in_values) (comma-separated list) + */ + meta_network_name_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * The index of the transaction within the block (filter: eq) + */ + transaction_index_eq?: number; + /** + * The index of the transaction within the block (filter: ne) + */ + transaction_index_ne?: number; + /** + * The index of the transaction within the block (filter: lt) + */ + transaction_index_lt?: number; + /** + * The index of the transaction within the block (filter: lte) + */ + transaction_index_lte?: number; + /** + * The index of the transaction within the block (filter: gt) + */ + transaction_index_gt?: number; + /** + * The index of the transaction within the block (filter: gte) + */ + transaction_index_gte?: number; + /** + * The index of the transaction within the block (filter: between_min) + */ + transaction_index_between_min?: number; + /** + * The index of the transaction within the block (filter: between_max_value) + */ + transaction_index_between_max_value?: number; + /** + * The index of the transaction within the block (filter: in_values) (comma-separated list) + */ + transaction_index_in_values?: string; + /** + * The index of the transaction within the block (filter: not_in_values) (comma-separated list) + */ + transaction_index_not_in_values?: string; + /** + * Number of times this opcode was executed in this frame (filter: eq) + */ + count_eq?: number; + /** + * Number of times this opcode was executed in this frame (filter: ne) + */ + count_ne?: number; + /** + * Number of times this opcode was executed in this frame (filter: lt) + */ + count_lt?: number; + /** + * Number of times this opcode was executed in this frame (filter: lte) + */ + count_lte?: number; + /** + * Number of times this opcode was executed in this frame (filter: gt) + */ + count_gt?: number; + /** + * Number of times this opcode was executed in this frame (filter: gte) + */ + count_gte?: number; + /** + * Number of times this opcode was executed in this frame (filter: between_min) + */ + count_between_min?: number; + /** + * Number of times this opcode was executed in this frame (filter: between_max_value) + */ + count_between_max_value?: number; + /** + * Number of times this opcode was executed in this frame (filter: in_values) (comma-separated list) + */ + count_in_values?: string; + /** + * Number of times this opcode was executed in this frame (filter: not_in_values) (comma-separated list) + */ + count_not_in_values?: string; + /** + * Total gas consumed by this opcode in this frame (filter: eq) + */ + gas_eq?: number; + /** + * Total gas consumed by this opcode in this frame (filter: ne) + */ + gas_ne?: number; + /** + * Total gas consumed by this opcode in this frame (filter: lt) + */ + gas_lt?: number; + /** + * Total gas consumed by this opcode in this frame (filter: lte) + */ + gas_lte?: number; + /** + * Total gas consumed by this opcode in this frame (filter: gt) + */ + gas_gt?: number; + /** + * Total gas consumed by this opcode in this frame (filter: gte) + */ + gas_gte?: number; + /** + * Total gas consumed by this opcode in this frame (filter: between_min) + */ + gas_between_min?: number; + /** + * Total gas consumed by this opcode in this frame (filter: between_max_value) + */ + gas_between_max_value?: number; + /** + * Total gas consumed by this opcode in this frame (filter: in_values) (comma-separated list) + */ + gas_in_values?: string; + /** + * Total gas consumed by this opcode in this frame (filter: not_in_values) (comma-separated list) + */ + gas_not_in_values?: string; + /** + * Gas attributed to pure computation (filter: eq) + */ + gas_compute_eq?: number; + /** + * Gas attributed to pure computation (filter: ne) + */ + gas_compute_ne?: number; + /** + * Gas attributed to pure computation (filter: lt) + */ + gas_compute_lt?: number; + /** + * Gas attributed to pure computation (filter: lte) + */ + gas_compute_lte?: number; + /** + * Gas attributed to pure computation (filter: gt) + */ + gas_compute_gt?: number; + /** + * Gas attributed to pure computation (filter: gte) + */ + gas_compute_gte?: number; + /** + * Gas attributed to pure computation (filter: between_min) + */ + gas_compute_between_min?: number; + /** + * Gas attributed to pure computation (filter: between_max_value) + */ + gas_compute_between_max_value?: number; + /** + * Gas attributed to pure computation (filter: in_values) (comma-separated list) + */ + gas_compute_in_values?: string; + /** + * Gas attributed to pure computation (filter: not_in_values) (comma-separated list) + */ + gas_compute_not_in_values?: string; + /** + * Gas attributed to memory expansion (filter: eq) + */ + gas_memory_eq?: number; + /** + * Gas attributed to memory expansion (filter: ne) + */ + gas_memory_ne?: number; + /** + * Gas attributed to memory expansion (filter: lt) + */ + gas_memory_lt?: number; + /** + * Gas attributed to memory expansion (filter: lte) + */ + gas_memory_lte?: number; + /** + * Gas attributed to memory expansion (filter: gt) + */ + gas_memory_gt?: number; + /** + * Gas attributed to memory expansion (filter: gte) + */ + gas_memory_gte?: number; + /** + * Gas attributed to memory expansion (filter: between_min) + */ + gas_memory_between_min?: number; + /** + * Gas attributed to memory expansion (filter: between_max_value) + */ + gas_memory_between_max_value?: number; + /** + * Gas attributed to memory expansion (filter: in_values) (comma-separated list) + */ + gas_memory_in_values?: string; + /** + * Gas attributed to memory expansion (filter: not_in_values) (comma-separated list) + */ + gas_memory_not_in_values?: string; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: eq) + */ + gas_address_access_eq?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: ne) + */ + gas_address_access_ne?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: lt) + */ + gas_address_access_lt?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: lte) + */ + gas_address_access_lte?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: gt) + */ + gas_address_access_gt?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: gte) + */ + gas_address_access_gte?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: between_min) + */ + gas_address_access_between_min?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: between_max_value) + */ + gas_address_access_between_max_value?: number; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: in_values) (comma-separated list) + */ + gas_address_access_in_values?: string; + /** + * Gas attributed to cold address/storage access (EIP-2929) (filter: not_in_values) (comma-separated list) + */ + gas_address_access_not_in_values?: string; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: eq) + */ + gas_state_growth_eq?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: ne) + */ + gas_state_growth_ne?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: lt) + */ + gas_state_growth_lt?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: lte) + */ + gas_state_growth_lte?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: gt) + */ + gas_state_growth_gt?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: gte) + */ + gas_state_growth_gte?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: between_min) + */ + gas_state_growth_between_min?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: between_max_value) + */ + gas_state_growth_between_max_value?: number; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: in_values) (comma-separated list) + */ + gas_state_growth_in_values?: string; + /** + * Gas attributed to state growth (new storage slots, contract creation) (filter: not_in_values) (comma-separated list) + */ + gas_state_growth_not_in_values?: string; + /** + * Gas attributed to history/log data storage (filter: eq) + */ + gas_history_eq?: number; + /** + * Gas attributed to history/log data storage (filter: ne) + */ + gas_history_ne?: number; + /** + * Gas attributed to history/log data storage (filter: lt) + */ + gas_history_lt?: number; + /** + * Gas attributed to history/log data storage (filter: lte) + */ + gas_history_lte?: number; + /** + * Gas attributed to history/log data storage (filter: gt) + */ + gas_history_gt?: number; + /** + * Gas attributed to history/log data storage (filter: gte) + */ + gas_history_gte?: number; + /** + * Gas attributed to history/log data storage (filter: between_min) + */ + gas_history_between_min?: number; + /** + * Gas attributed to history/log data storage (filter: between_max_value) + */ + gas_history_between_max_value?: number; + /** + * Gas attributed to history/log data storage (filter: in_values) (comma-separated list) + */ + gas_history_in_values?: string; + /** + * Gas attributed to history/log data storage (filter: not_in_values) (comma-separated list) + */ + gas_history_not_in_values?: string; + /** + * Gas attributed to bloom filter topic indexing (filter: eq) + */ + gas_bloom_topics_eq?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: ne) + */ + gas_bloom_topics_ne?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: lt) + */ + gas_bloom_topics_lt?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: lte) + */ + gas_bloom_topics_lte?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: gt) + */ + gas_bloom_topics_gt?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: gte) + */ + gas_bloom_topics_gte?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: between_min) + */ + gas_bloom_topics_between_min?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: between_max_value) + */ + gas_bloom_topics_between_max_value?: number; + /** + * Gas attributed to bloom filter topic indexing (filter: in_values) (comma-separated list) + */ + gas_bloom_topics_in_values?: string; + /** + * Gas attributed to bloom filter topic indexing (filter: not_in_values) (comma-separated list) + */ + gas_bloom_topics_not_in_values?: string; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: eq) + */ + gas_block_size_eq?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: ne) + */ + gas_block_size_ne?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: lt) + */ + gas_block_size_lt?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: lte) + */ + gas_block_size_lte?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: gt) + */ + gas_block_size_gt?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: gte) + */ + gas_block_size_gte?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: between_min) + */ + gas_block_size_between_min?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: between_max_value) + */ + gas_block_size_between_max_value?: number; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: in_values) (comma-separated list) + */ + gas_block_size_in_values?: string; + /** + * Gas attributed to block size (always 0 at opcode level) (filter: not_in_values) (comma-separated list) + */ + gas_block_size_not_in_values?: string; + /** + * The maximum number of int_transaction_call_frame_opcode_resource_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListIntTransactionCallFrameOpcodeResourceGas` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/int_transaction_call_frame_opcode_resource_gas'; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceListError = + IntTransactionCallFrameOpcodeResourceGasServiceListErrors[keyof IntTransactionCallFrameOpcodeResourceGasServiceListErrors]; + +export type IntTransactionCallFrameOpcodeResourceGasServiceListResponses = { + /** + * OK + */ + 200: ListIntTransactionCallFrameOpcodeResourceGasResponse; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceListResponse = + IntTransactionCallFrameOpcodeResourceGasServiceListResponses[keyof IntTransactionCallFrameOpcodeResourceGasServiceListResponses]; + +export type IntTransactionCallFrameOpcodeResourceGasServiceGetData = { + body?: never; + path: { + /** + * The block number containing the transaction + */ + block_number: number; + }; + query?: never; + url: '/api/v1/int_transaction_call_frame_opcode_resource_gas/{block_number}'; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceGetError = + IntTransactionCallFrameOpcodeResourceGasServiceGetErrors[keyof IntTransactionCallFrameOpcodeResourceGasServiceGetErrors]; + +export type IntTransactionCallFrameOpcodeResourceGasServiceGetResponses = { + /** + * OK + */ + 200: GetIntTransactionCallFrameOpcodeResourceGasResponse; +}; + +export type IntTransactionCallFrameOpcodeResourceGasServiceGetResponse = + IntTransactionCallFrameOpcodeResourceGasServiceGetResponses[keyof IntTransactionCallFrameOpcodeResourceGasServiceGetResponses]; + +export type IntTransactionOpcodeGasServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The block number containing the transaction (filter: eq) + */ + block_number_eq?: number; + /** + * The block number containing the transaction (filter: ne) + */ + block_number_ne?: number; + /** + * The block number containing the transaction (filter: lt) + */ + block_number_lt?: number; + /** + * The block number containing the transaction (filter: lte) + */ + block_number_lte?: number; + /** + * The block number containing the transaction (filter: gt) + */ + block_number_gt?: number; + /** + * The block number containing the transaction (filter: gte) + */ + block_number_gte?: number; + /** + * The block number containing the transaction (filter: between_min) + */ + block_number_between_min?: number; + /** + * The block number containing the transaction (filter: between_max_value) + */ + block_number_between_max_value?: number; + /** + * The block number containing the transaction (filter: in_values) (comma-separated list) + */ + block_number_in_values?: string; + /** + * The block number containing the transaction (filter: not_in_values) (comma-separated list) + */ + block_number_not_in_values?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: eq) + */ + transaction_hash_eq?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: ne) + */ + transaction_hash_ne?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: contains) + */ + transaction_hash_contains?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: starts_with) + */ + transaction_hash_starts_with?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: ends_with) + */ + transaction_hash_ends_with?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: like) + */ + transaction_hash_like?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: not_like) + */ + transaction_hash_not_like?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: in_values) (comma-separated list) + */ + transaction_hash_in_values?: string; + /** + * The transaction hash (hex encoded with 0x prefix) (filter: not_in_values) (comma-separated list) + */ + transaction_hash_not_in_values?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: eq) + */ + opcode_eq?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ne) + */ + opcode_ne?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: contains) + */ + opcode_contains?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: starts_with) + */ + opcode_starts_with?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ends_with) + */ + opcode_ends_with?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: like) + */ + opcode_like?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_like) + */ + opcode_not_like?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: in_values) (comma-separated list) + */ + opcode_in_values?: string; + /** + * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_in_values) (comma-separated list) + */ + opcode_not_in_values?: string; + /** + * The name of the network (filter: eq) + */ + meta_network_name_eq?: string; + /** + * The name of the network (filter: ne) + */ + meta_network_name_ne?: string; + /** + * The name of the network (filter: contains) + */ + meta_network_name_contains?: string; + /** + * The name of the network (filter: starts_with) + */ + meta_network_name_starts_with?: string; + /** + * The name of the network (filter: ends_with) + */ + meta_network_name_ends_with?: string; + /** + * The name of the network (filter: like) + */ + meta_network_name_like?: string; + /** + * The name of the network (filter: not_like) + */ + meta_network_name_not_like?: string; + /** + * The name of the network (filter: in_values) (comma-separated list) + */ + meta_network_name_in_values?: string; + /** + * The name of the network (filter: not_in_values) (comma-separated list) + */ + meta_network_name_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * The index of the transaction within the block (filter: eq) + */ + transaction_index_eq?: number; + /** + * The index of the transaction within the block (filter: ne) + */ + transaction_index_ne?: number; + /** + * The index of the transaction within the block (filter: lt) + */ + transaction_index_lt?: number; + /** + * The index of the transaction within the block (filter: lte) + */ + transaction_index_lte?: number; + /** + * The index of the transaction within the block (filter: gt) + */ + transaction_index_gt?: number; + /** + * The index of the transaction within the block (filter: gte) + */ + transaction_index_gte?: number; + /** + * The index of the transaction within the block (filter: between_min) + */ + transaction_index_between_min?: number; + /** + * The index of the transaction within the block (filter: between_max_value) + */ + transaction_index_between_max_value?: number; + /** + * The index of the transaction within the block (filter: in_values) (comma-separated list) + */ + transaction_index_in_values?: string; + /** + * The index of the transaction within the block (filter: not_in_values) (comma-separated list) + */ + transaction_index_not_in_values?: string; + /** + * Number of times this opcode was executed in the transaction (filter: eq) */ count_eq?: number; /** - * Number of times this opcode was executed in this frame (filter: ne) + * Number of times this opcode was executed in the transaction (filter: ne) */ count_ne?: number; /** - * Number of times this opcode was executed in this frame (filter: lt) + * Number of times this opcode was executed in the transaction (filter: lt) */ count_lt?: number; /** - * Number of times this opcode was executed in this frame (filter: lte) + * Number of times this opcode was executed in the transaction (filter: lte) */ count_lte?: number; /** - * Number of times this opcode was executed in this frame (filter: gt) + * Number of times this opcode was executed in the transaction (filter: gt) */ count_gt?: number; /** - * Number of times this opcode was executed in this frame (filter: gte) + * Number of times this opcode was executed in the transaction (filter: gte) */ count_gte?: number; /** - * Number of times this opcode was executed in this frame (filter: between_min) + * Number of times this opcode was executed in the transaction (filter: between_min) */ count_between_min?: number; /** - * Number of times this opcode was executed in this frame (filter: between_max_value) + * Number of times this opcode was executed in the transaction (filter: between_max_value) */ count_between_max_value?: number; /** - * Number of times this opcode was executed in this frame (filter: in_values) (comma-separated list) + * Number of times this opcode was executed in the transaction (filter: in_values) (comma-separated list) */ count_in_values?: string; /** - * Number of times this opcode was executed in this frame (filter: not_in_values) (comma-separated list) + * Number of times this opcode was executed in the transaction (filter: not_in_values) (comma-separated list) */ count_not_in_values?: string; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: eq) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: eq) */ gas_eq?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: ne) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: ne) */ gas_ne?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: lt) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: lt) */ gas_lt?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: lte) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: lte) */ gas_lte?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: gt) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: gt) */ gas_gt?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: gte) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: gte) */ gas_gte?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: between_min) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: between_min) */ gas_between_min?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: between_max_value) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: between_max_value) */ gas_between_max_value?: number; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: in_values) (comma-separated list) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: in_values) (comma-separated list) */ gas_in_values?: string; /** - * Gas consumed by this opcode in this frame. sum(gas) = frame gas (filter: not_in_values) (comma-separated list) + * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: not_in_values) (comma-separated list) */ gas_not_in_values?: string; /** @@ -92614,51 +94778,51 @@ export type IntTransactionCallFrameOpcodeGasServiceListData = { */ gas_cumulative_not_in_values?: string; /** - * Number of times this opcode resulted in an error in this frame (filter: eq) + * Number of times this opcode resulted in an error (filter: eq) */ error_count_eq?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: ne) + * Number of times this opcode resulted in an error (filter: ne) */ error_count_ne?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: lt) + * Number of times this opcode resulted in an error (filter: lt) */ error_count_lt?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: lte) + * Number of times this opcode resulted in an error (filter: lte) */ error_count_lte?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: gt) + * Number of times this opcode resulted in an error (filter: gt) */ error_count_gt?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: gte) + * Number of times this opcode resulted in an error (filter: gte) */ error_count_gte?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: between_min) + * Number of times this opcode resulted in an error (filter: between_min) */ error_count_between_min?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: between_max_value) + * Number of times this opcode resulted in an error (filter: between_max_value) */ error_count_between_max_value?: number; /** - * Number of times this opcode resulted in an error in this frame (filter: in_values) (comma-separated list) + * Number of times this opcode resulted in an error (filter: in_values) (comma-separated list) */ error_count_in_values?: string; /** - * Number of times this opcode resulted in an error in this frame (filter: not_in_values) (comma-separated list) + * Number of times this opcode resulted in an error (filter: not_in_values) (comma-separated list) */ error_count_not_in_values?: string; /** - * The maximum number of int_transaction_call_frame_opcode_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + * The maximum number of int_transaction_opcode_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. */ page_size?: number; /** - * A page token, received from a previous `ListIntTransactionCallFrameOpcodeGas` call. Provide this to retrieve the subsequent page. + * A page token, received from a previous `ListIntTransactionOpcodeGas` call. Provide this to retrieve the subsequent page. */ page_token?: string; /** @@ -92666,30 +94830,30 @@ export type IntTransactionCallFrameOpcodeGasServiceListData = { */ order_by?: string; }; - url: '/api/v1/int_transaction_call_frame_opcode_gas'; + url: '/api/v1/int_transaction_opcode_gas'; }; -export type IntTransactionCallFrameOpcodeGasServiceListErrors = { +export type IntTransactionOpcodeGasServiceListErrors = { /** * Default error response */ default: Status; }; -export type IntTransactionCallFrameOpcodeGasServiceListError = - IntTransactionCallFrameOpcodeGasServiceListErrors[keyof IntTransactionCallFrameOpcodeGasServiceListErrors]; +export type IntTransactionOpcodeGasServiceListError = + IntTransactionOpcodeGasServiceListErrors[keyof IntTransactionOpcodeGasServiceListErrors]; -export type IntTransactionCallFrameOpcodeGasServiceListResponses = { +export type IntTransactionOpcodeGasServiceListResponses = { /** * OK */ - 200: ListIntTransactionCallFrameOpcodeGasResponse; + 200: ListIntTransactionOpcodeGasResponse; }; -export type IntTransactionCallFrameOpcodeGasServiceListResponse = - IntTransactionCallFrameOpcodeGasServiceListResponses[keyof IntTransactionCallFrameOpcodeGasServiceListResponses]; +export type IntTransactionOpcodeGasServiceListResponse = + IntTransactionOpcodeGasServiceListResponses[keyof IntTransactionOpcodeGasServiceListResponses]; -export type IntTransactionCallFrameOpcodeGasServiceGetData = { +export type IntTransactionOpcodeGasServiceGetData = { body?: never; path: { /** @@ -92698,30 +94862,30 @@ export type IntTransactionCallFrameOpcodeGasServiceGetData = { block_number: number; }; query?: never; - url: '/api/v1/int_transaction_call_frame_opcode_gas/{block_number}'; + url: '/api/v1/int_transaction_opcode_gas/{block_number}'; }; -export type IntTransactionCallFrameOpcodeGasServiceGetErrors = { +export type IntTransactionOpcodeGasServiceGetErrors = { /** * Default error response */ default: Status; }; -export type IntTransactionCallFrameOpcodeGasServiceGetError = - IntTransactionCallFrameOpcodeGasServiceGetErrors[keyof IntTransactionCallFrameOpcodeGasServiceGetErrors]; +export type IntTransactionOpcodeGasServiceGetError = + IntTransactionOpcodeGasServiceGetErrors[keyof IntTransactionOpcodeGasServiceGetErrors]; -export type IntTransactionCallFrameOpcodeGasServiceGetResponses = { +export type IntTransactionOpcodeGasServiceGetResponses = { /** * OK */ - 200: GetIntTransactionCallFrameOpcodeGasResponse; + 200: GetIntTransactionOpcodeGasResponse; }; -export type IntTransactionCallFrameOpcodeGasServiceGetResponse = - IntTransactionCallFrameOpcodeGasServiceGetResponses[keyof IntTransactionCallFrameOpcodeGasServiceGetResponses]; +export type IntTransactionOpcodeGasServiceGetResponse = + IntTransactionOpcodeGasServiceGetResponses[keyof IntTransactionOpcodeGasServiceGetResponses]; -export type IntTransactionOpcodeGasServiceListData = { +export type IntTransactionResourceGasServiceListData = { body?: never; path?: never; query?: { @@ -92801,42 +94965,6 @@ export type IntTransactionOpcodeGasServiceListData = { * The transaction hash (hex encoded with 0x prefix) (filter: not_in_values) (comma-separated list) */ transaction_hash_not_in_values?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: eq) - */ - opcode_eq?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ne) - */ - opcode_ne?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: contains) - */ - opcode_contains?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: starts_with) - */ - opcode_starts_with?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: ends_with) - */ - opcode_ends_with?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: like) - */ - opcode_like?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_like) - */ - opcode_not_like?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: in_values) (comma-separated list) - */ - opcode_in_values?: string; - /** - * The EVM opcode name (e.g., SLOAD, ADD, CALL) (filter: not_in_values) (comma-separated list) - */ - opcode_not_in_values?: string; /** * The name of the network (filter: eq) */ @@ -92954,171 +95082,331 @@ export type IntTransactionOpcodeGasServiceListData = { */ transaction_index_not_in_values?: string; /** - * Number of times this opcode was executed in the transaction (filter: eq) + * Total compute gas (EVM execution + intrinsic compute) (filter: eq) */ - count_eq?: number; + gas_compute_eq?: number; /** - * Number of times this opcode was executed in the transaction (filter: ne) + * Total compute gas (EVM execution + intrinsic compute) (filter: ne) */ - count_ne?: number; + gas_compute_ne?: number; /** - * Number of times this opcode was executed in the transaction (filter: lt) + * Total compute gas (EVM execution + intrinsic compute) (filter: lt) */ - count_lt?: number; + gas_compute_lt?: number; /** - * Number of times this opcode was executed in the transaction (filter: lte) + * Total compute gas (EVM execution + intrinsic compute) (filter: lte) */ - count_lte?: number; + gas_compute_lte?: number; /** - * Number of times this opcode was executed in the transaction (filter: gt) + * Total compute gas (EVM execution + intrinsic compute) (filter: gt) */ - count_gt?: number; + gas_compute_gt?: number; /** - * Number of times this opcode was executed in the transaction (filter: gte) + * Total compute gas (EVM execution + intrinsic compute) (filter: gte) */ - count_gte?: number; + gas_compute_gte?: number; /** - * Number of times this opcode was executed in the transaction (filter: between_min) + * Total compute gas (EVM execution + intrinsic compute) (filter: between_min) */ - count_between_min?: number; + gas_compute_between_min?: number; /** - * Number of times this opcode was executed in the transaction (filter: between_max_value) + * Total compute gas (EVM execution + intrinsic compute) (filter: between_max_value) */ - count_between_max_value?: number; + gas_compute_between_max_value?: number; /** - * Number of times this opcode was executed in the transaction (filter: in_values) (comma-separated list) + * Total compute gas (EVM execution + intrinsic compute) (filter: in_values) (comma-separated list) */ - count_in_values?: string; + gas_compute_in_values?: string; /** - * Number of times this opcode was executed in the transaction (filter: not_in_values) (comma-separated list) + * Total compute gas (EVM execution + intrinsic compute) (filter: not_in_values) (comma-separated list) */ - count_not_in_values?: string; + gas_compute_not_in_values?: string; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: eq) + * Total memory expansion gas (filter: eq) */ - gas_eq?: number; + gas_memory_eq?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: ne) + * Total memory expansion gas (filter: ne) */ - gas_ne?: number; + gas_memory_ne?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: lt) + * Total memory expansion gas (filter: lt) */ - gas_lt?: number; + gas_memory_lt?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: lte) + * Total memory expansion gas (filter: lte) */ - gas_lte?: number; + gas_memory_lte?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: gt) + * Total memory expansion gas (filter: gt) */ - gas_gt?: number; + gas_memory_gt?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: gte) + * Total memory expansion gas (filter: gte) */ - gas_gte?: number; + gas_memory_gte?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: between_min) + * Total memory expansion gas (filter: between_min) */ - gas_between_min?: number; + gas_memory_between_min?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: between_max_value) + * Total memory expansion gas (filter: between_max_value) */ - gas_between_max_value?: number; + gas_memory_between_max_value?: number; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: in_values) (comma-separated list) + * Total memory expansion gas (filter: in_values) (comma-separated list) */ - gas_in_values?: string; + gas_memory_in_values?: string; /** - * Gas consumed by this opcode. sum(gas) = transaction executed gas (filter: not_in_values) (comma-separated list) + * Total memory expansion gas (filter: not_in_values) (comma-separated list) */ - gas_not_in_values?: string; + gas_memory_not_in_values?: string; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: eq) + * Total cold address/storage access gas (filter: eq) */ - gas_cumulative_eq?: number; + gas_address_access_eq?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: ne) + * Total cold address/storage access gas (filter: ne) */ - gas_cumulative_ne?: number; + gas_address_access_ne?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: lt) + * Total cold address/storage access gas (filter: lt) */ - gas_cumulative_lt?: number; + gas_address_access_lt?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: lte) + * Total cold address/storage access gas (filter: lte) */ - gas_cumulative_lte?: number; + gas_address_access_lte?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: gt) + * Total cold address/storage access gas (filter: gt) */ - gas_cumulative_gt?: number; + gas_address_access_gt?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: gte) + * Total cold address/storage access gas (filter: gte) */ - gas_cumulative_gte?: number; + gas_address_access_gte?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: between_min) + * Total cold address/storage access gas (filter: between_min) */ - gas_cumulative_between_min?: number; + gas_address_access_between_min?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: between_max_value) + * Total cold address/storage access gas (filter: between_max_value) */ - gas_cumulative_between_max_value?: number; + gas_address_access_between_max_value?: number; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: in_values) (comma-separated list) + * Total cold address/storage access gas (filter: in_values) (comma-separated list) */ - gas_cumulative_in_values?: string; + gas_address_access_in_values?: string; /** - * For CALL opcodes: includes all descendant frame gas. For others: same as gas (filter: not_in_values) (comma-separated list) + * Total cold address/storage access gas (filter: not_in_values) (comma-separated list) */ - gas_cumulative_not_in_values?: string; + gas_address_access_not_in_values?: string; /** - * Number of times this opcode resulted in an error (filter: eq) + * Total state growth gas (filter: eq) */ - error_count_eq?: number; + gas_state_growth_eq?: number; /** - * Number of times this opcode resulted in an error (filter: ne) + * Total state growth gas (filter: ne) */ - error_count_ne?: number; + gas_state_growth_ne?: number; /** - * Number of times this opcode resulted in an error (filter: lt) + * Total state growth gas (filter: lt) */ - error_count_lt?: number; + gas_state_growth_lt?: number; /** - * Number of times this opcode resulted in an error (filter: lte) + * Total state growth gas (filter: lte) */ - error_count_lte?: number; + gas_state_growth_lte?: number; /** - * Number of times this opcode resulted in an error (filter: gt) + * Total state growth gas (filter: gt) */ - error_count_gt?: number; + gas_state_growth_gt?: number; /** - * Number of times this opcode resulted in an error (filter: gte) + * Total state growth gas (filter: gte) */ - error_count_gte?: number; + gas_state_growth_gte?: number; /** - * Number of times this opcode resulted in an error (filter: between_min) + * Total state growth gas (filter: between_min) */ - error_count_between_min?: number; + gas_state_growth_between_min?: number; /** - * Number of times this opcode resulted in an error (filter: between_max_value) + * Total state growth gas (filter: between_max_value) */ - error_count_between_max_value?: number; + gas_state_growth_between_max_value?: number; /** - * Number of times this opcode resulted in an error (filter: in_values) (comma-separated list) + * Total state growth gas (filter: in_values) (comma-separated list) */ - error_count_in_values?: string; + gas_state_growth_in_values?: string; /** - * Number of times this opcode resulted in an error (filter: not_in_values) (comma-separated list) + * Total state growth gas (filter: not_in_values) (comma-separated list) */ - error_count_not_in_values?: string; + gas_state_growth_not_in_values?: string; /** - * The maximum number of int_transaction_opcode_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + * Total history/log data gas (filter: eq) + */ + gas_history_eq?: number; + /** + * Total history/log data gas (filter: ne) + */ + gas_history_ne?: number; + /** + * Total history/log data gas (filter: lt) + */ + gas_history_lt?: number; + /** + * Total history/log data gas (filter: lte) + */ + gas_history_lte?: number; + /** + * Total history/log data gas (filter: gt) + */ + gas_history_gt?: number; + /** + * Total history/log data gas (filter: gte) + */ + gas_history_gte?: number; + /** + * Total history/log data gas (filter: between_min) + */ + gas_history_between_min?: number; + /** + * Total history/log data gas (filter: between_max_value) + */ + gas_history_between_max_value?: number; + /** + * Total history/log data gas (filter: in_values) (comma-separated list) + */ + gas_history_in_values?: string; + /** + * Total history/log data gas (filter: not_in_values) (comma-separated list) + */ + gas_history_not_in_values?: string; + /** + * Total bloom filter topic gas (filter: eq) + */ + gas_bloom_topics_eq?: number; + /** + * Total bloom filter topic gas (filter: ne) + */ + gas_bloom_topics_ne?: number; + /** + * Total bloom filter topic gas (filter: lt) + */ + gas_bloom_topics_lt?: number; + /** + * Total bloom filter topic gas (filter: lte) + */ + gas_bloom_topics_lte?: number; + /** + * Total bloom filter topic gas (filter: gt) + */ + gas_bloom_topics_gt?: number; + /** + * Total bloom filter topic gas (filter: gte) + */ + gas_bloom_topics_gte?: number; + /** + * Total bloom filter topic gas (filter: between_min) + */ + gas_bloom_topics_between_min?: number; + /** + * Total bloom filter topic gas (filter: between_max_value) + */ + gas_bloom_topics_between_max_value?: number; + /** + * Total bloom filter topic gas (filter: in_values) (comma-separated list) + */ + gas_bloom_topics_in_values?: string; + /** + * Total bloom filter topic gas (filter: not_in_values) (comma-separated list) + */ + gas_bloom_topics_not_in_values?: string; + /** + * Total block size gas (from intrinsic calldata) (filter: eq) + */ + gas_block_size_eq?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: ne) + */ + gas_block_size_ne?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: lt) + */ + gas_block_size_lt?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: lte) + */ + gas_block_size_lte?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: gt) + */ + gas_block_size_gt?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: gte) + */ + gas_block_size_gte?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: between_min) + */ + gas_block_size_between_min?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: between_max_value) + */ + gas_block_size_between_max_value?: number; + /** + * Total block size gas (from intrinsic calldata) (filter: in_values) (comma-separated list) + */ + gas_block_size_in_values?: string; + /** + * Total block size gas (from intrinsic calldata) (filter: not_in_values) (comma-separated list) + */ + gas_block_size_not_in_values?: string; + /** + * Gas refund from SSTORE operations (filter: eq) + */ + gas_refund_eq?: number; + /** + * Gas refund from SSTORE operations (filter: ne) + */ + gas_refund_ne?: number; + /** + * Gas refund from SSTORE operations (filter: lt) + */ + gas_refund_lt?: number; + /** + * Gas refund from SSTORE operations (filter: lte) + */ + gas_refund_lte?: number; + /** + * Gas refund from SSTORE operations (filter: gt) + */ + gas_refund_gt?: number; + /** + * Gas refund from SSTORE operations (filter: gte) + */ + gas_refund_gte?: number; + /** + * Gas refund from SSTORE operations (filter: between_min) + */ + gas_refund_between_min?: number; + /** + * Gas refund from SSTORE operations (filter: between_max_value) + */ + gas_refund_between_max_value?: number; + /** + * Gas refund from SSTORE operations (filter: in_values) (comma-separated list) + */ + gas_refund_in_values?: string; + /** + * Gas refund from SSTORE operations (filter: not_in_values) (comma-separated list) + */ + gas_refund_not_in_values?: string; + /** + * The maximum number of int_transaction_resource_gas to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. */ page_size?: number; /** - * A page token, received from a previous `ListIntTransactionOpcodeGas` call. Provide this to retrieve the subsequent page. + * A page token, received from a previous `ListIntTransactionResourceGas` call. Provide this to retrieve the subsequent page. */ page_token?: string; /** @@ -93126,30 +95414,30 @@ export type IntTransactionOpcodeGasServiceListData = { */ order_by?: string; }; - url: '/api/v1/int_transaction_opcode_gas'; + url: '/api/v1/int_transaction_resource_gas'; }; -export type IntTransactionOpcodeGasServiceListErrors = { +export type IntTransactionResourceGasServiceListErrors = { /** * Default error response */ default: Status; }; -export type IntTransactionOpcodeGasServiceListError = - IntTransactionOpcodeGasServiceListErrors[keyof IntTransactionOpcodeGasServiceListErrors]; +export type IntTransactionResourceGasServiceListError = + IntTransactionResourceGasServiceListErrors[keyof IntTransactionResourceGasServiceListErrors]; -export type IntTransactionOpcodeGasServiceListResponses = { +export type IntTransactionResourceGasServiceListResponses = { /** * OK */ - 200: ListIntTransactionOpcodeGasResponse; + 200: ListIntTransactionResourceGasResponse; }; -export type IntTransactionOpcodeGasServiceListResponse = - IntTransactionOpcodeGasServiceListResponses[keyof IntTransactionOpcodeGasServiceListResponses]; +export type IntTransactionResourceGasServiceListResponse = + IntTransactionResourceGasServiceListResponses[keyof IntTransactionResourceGasServiceListResponses]; -export type IntTransactionOpcodeGasServiceGetData = { +export type IntTransactionResourceGasServiceGetData = { body?: never; path: { /** @@ -93158,25 +95446,25 @@ export type IntTransactionOpcodeGasServiceGetData = { block_number: number; }; query?: never; - url: '/api/v1/int_transaction_opcode_gas/{block_number}'; + url: '/api/v1/int_transaction_resource_gas/{block_number}'; }; -export type IntTransactionOpcodeGasServiceGetErrors = { +export type IntTransactionResourceGasServiceGetErrors = { /** * Default error response */ default: Status; }; -export type IntTransactionOpcodeGasServiceGetError = - IntTransactionOpcodeGasServiceGetErrors[keyof IntTransactionOpcodeGasServiceGetErrors]; +export type IntTransactionResourceGasServiceGetError = + IntTransactionResourceGasServiceGetErrors[keyof IntTransactionResourceGasServiceGetErrors]; -export type IntTransactionOpcodeGasServiceGetResponses = { +export type IntTransactionResourceGasServiceGetResponses = { /** * OK */ - 200: GetIntTransactionOpcodeGasResponse; + 200: GetIntTransactionResourceGasResponse; }; -export type IntTransactionOpcodeGasServiceGetResponse = - IntTransactionOpcodeGasServiceGetResponses[keyof IntTransactionOpcodeGasServiceGetResponses]; +export type IntTransactionResourceGasServiceGetResponse = + IntTransactionResourceGasServiceGetResponses[keyof IntTransactionResourceGasServiceGetResponses]; diff --git a/src/api/zod.gen.ts b/src/api/zod.gen.ts index 99d0f0579..6cbf05ecf 100644 --- a/src/api/zod.gen.ts +++ b/src/api/zod.gen.ts @@ -10012,6 +10012,115 @@ export const zGetIntBlockProposerCanonicalResponse = z.object({ item: z.optional(zIntBlockProposerCanonical), }); +export const zIntBlockResourceGas = z.object({ + block_number: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_compute: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_memory: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + meta_network_name: z.optional(z.string()), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +/** + * Response for getting a single int_block_resource_gas record + */ +export const zGetIntBlockResourceGasResponse = z.object({ + item: z.optional(zIntBlockResourceGas), +}); + export const zIntContractCreation = z.object({ block_number: z.optional( z @@ -13169,6 +13278,16 @@ export const zIntTransactionCallFrameOpcodeGas = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), + cold_access_count: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), count: z.optional( z.coerce .bigint() @@ -13209,6 +13328,56 @@ export const zIntTransactionCallFrameOpcodeGas = z.object({ }) ) ), + memory_expansion_gas: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + memory_words_sq_sum_after: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + memory_words_sq_sum_before: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + memory_words_sum_after: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + memory_words_sum_before: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), meta_network_name: z.optional(z.string()), opcode: z.optional(z.string()), transaction_hash: z.optional(z.string()), @@ -13237,6 +13406,143 @@ export const zGetIntTransactionCallFrameOpcodeGasResponse = z.object({ item: z.optional(zIntTransactionCallFrameOpcodeGas), }); +export const zIntTransactionCallFrameOpcodeResourceGas = z.object({ + block_number: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + call_frame_id: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + count: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_compute: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_memory: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + meta_network_name: z.optional(z.string()), + opcode: z.optional(z.string()), + transaction_hash: z.optional(z.string()), + transaction_index: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +/** + * Response for getting a single int_transaction_call_frame_opcode_resource_gas record + */ +export const zGetIntTransactionCallFrameOpcodeResourceGasResponse = z.object({ + item: z.optional(zIntTransactionCallFrameOpcodeResourceGas), +}); + export const zIntTransactionOpcodeGas = z.object({ block_number: z.optional( z.coerce @@ -13316,6 +13622,124 @@ export const zGetIntTransactionOpcodeGasResponse = z.object({ item: z.optional(zIntTransactionOpcodeGas), }); +export const zIntTransactionResourceGas = z.object({ + block_number: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_compute: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_memory: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + meta_network_name: z.optional(z.string()), + transaction_hash: z.optional(z.string()), + transaction_index: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +/** + * Response for getting a single int_transaction_resource_gas record + */ +export const zGetIntTransactionResourceGasResponse = z.object({ + item: z.optional(zIntTransactionResourceGas), +}); + /** * Response for listing admin_cbt_incremental records */ @@ -14396,6 +14820,14 @@ export const zListIntBlockProposerCanonicalResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing int_block_resource_gas records + */ +export const zListIntBlockResourceGasResponse = z.object({ + int_block_resource_gas: z.optional(z.array(zIntBlockResourceGas)), + next_page_token: z.optional(z.string()), +}); + /** * Response for listing int_contract_creation records */ @@ -14774,6 +15206,14 @@ export const zListIntTransactionCallFrameOpcodeGasResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing int_transaction_call_frame_opcode_resource_gas records + */ +export const zListIntTransactionCallFrameOpcodeResourceGasResponse = z.object({ + int_transaction_call_frame_opcode_resource_gas: z.optional(z.array(zIntTransactionCallFrameOpcodeResourceGas)), + next_page_token: z.optional(z.string()), +}); + /** * Response for listing int_transaction_call_frame records */ @@ -14790,6 +15230,14 @@ export const zListIntTransactionOpcodeGasResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing int_transaction_resource_gas records + */ +export const zListIntTransactionResourceGasResponse = z.object({ + int_transaction_resource_gas: z.optional(z.array(zIntTransactionResourceGas)), + next_page_token: z.optional(z.string()), +}); + /** * The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors). */ @@ -89177,95 +89625,102 @@ export const zIntBlockProposerCanonicalServiceGetData = z.object({ */ export const zIntBlockProposerCanonicalServiceGetResponse = zGetIntBlockProposerCanonicalResponse; -export const zIntContractCreationServiceListData = z.object({ +export const zIntBlockResourceGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ block_number_eq: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_ne: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_lt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_lte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_gt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_gte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_between_min: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_between_max_value: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_address_eq: z.optional(z.string()), - contract_address_ne: z.optional(z.string()), - contract_address_contains: z.optional(z.string()), - contract_address_starts_with: z.optional(z.string()), - contract_address_ends_with: z.optional(z.string()), - contract_address_like: z.optional(z.string()), - contract_address_not_like: z.optional(z.string()), - contract_address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - contract_address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - transaction_hash_eq: z.optional(z.string()), - transaction_hash_ne: z.optional(z.string()), - transaction_hash_contains: z.optional(z.string()), - transaction_hash_starts_with: z.optional(z.string()), - transaction_hash_ends_with: z.optional(z.string()), - transaction_hash_like: z.optional(z.string()), - transaction_hash_not_like: z.optional(z.string()), - transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_eq: z.optional(z.string()), + meta_network_name_ne: z.optional(z.string()), + meta_network_name_contains: z.optional(z.string()), + meta_network_name_starts_with: z.optional(z.string()), + meta_network_name_ends_with: z.optional(z.string()), + meta_network_name_like: z.optional(z.string()), + meta_network_name_not_like: z.optional(z.string()), + meta_network_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -89332,230 +89787,1914 @@ export const zIntContractCreationServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_eq: z.optional( - z - .int() + gas_compute_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_ne: z.optional( - z - .int() + gas_compute_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_lt: z.optional( - z - .int() + gas_compute_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_lte: z.optional( - z - .int() + gas_compute_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_gt: z.optional( - z - .int() + gas_compute_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_gte: z.optional( - z - .int() + gas_compute_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_between_min: z.optional( - z - .int() + gas_compute_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_between_max_value: z.optional( - z - .int() + gas_compute_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - internal_index_eq: z.optional( - z - .int() + gas_compute_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_compute_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_ne: z.optional( - z - .int() + gas_memory_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_lt: z.optional( - z - .int() + gas_memory_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_lte: z.optional( - z - .int() + gas_memory_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_gt: z.optional( - z - .int() + gas_memory_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_gte: z.optional( - z - .int() + gas_memory_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_between_min: z.optional( - z - .int() + gas_memory_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_between_max_value: z.optional( - z - .int() + gas_memory_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - deployer_eq: z.optional(z.string()), - deployer_ne: z.optional(z.string()), - deployer_contains: z.optional(z.string()), - deployer_starts_with: z.optional(z.string()), - deployer_ends_with: z.optional(z.string()), - deployer_like: z.optional(z.string()), - deployer_not_like: z.optional(z.string()), - deployer_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - deployer_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - factory_eq: z.optional(z.string()), - factory_ne: z.optional(z.string()), - factory_contains: z.optional(z.string()), - factory_starts_with: z.optional(z.string()), - factory_ends_with: z.optional(z.string()), - factory_like: z.optional(z.string()), - factory_not_like: z.optional(z.string()), - factory_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - factory_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - init_code_hash_eq: z.optional(z.string()), - init_code_hash_ne: z.optional(z.string()), - init_code_hash_contains: z.optional(z.string()), - init_code_hash_starts_with: z.optional(z.string()), - init_code_hash_ends_with: z.optional(z.string()), - init_code_hash_like: z.optional(z.string()), - init_code_hash_not_like: z.optional(z.string()), - init_code_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - init_code_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - page_size: z.optional( - z - .int() + gas_memory_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntContractCreationServiceListResponse = zListIntContractCreationResponse; - -export const zIntContractCreationServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntContractCreationServiceGetResponse = zGetIntContractCreationResponse; - -export const zIntContractSelfdestructServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - block_number_eq: z.optional( - z - .int() + gas_address_access_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - block_number_ne: z.optional( - z - .int() + gas_address_access_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - block_number_lt: z.optional( - z - .int() + gas_address_access_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_address_access_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_state_growth_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntBlockResourceGasServiceListResponse = zListIntBlockResourceGasResponse; + +export const zIntBlockResourceGasServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntBlockResourceGasServiceGetResponse = zGetIntBlockResourceGasResponse; + +export const zIntContractCreationServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_address_eq: z.optional(z.string()), + contract_address_ne: z.optional(z.string()), + contract_address_contains: z.optional(z.string()), + contract_address_starts_with: z.optional(z.string()), + contract_address_ends_with: z.optional(z.string()), + contract_address_like: z.optional(z.string()), + contract_address_not_like: z.optional(z.string()), + contract_address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + contract_address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_eq: z.optional(z.string()), + transaction_hash_ne: z.optional(z.string()), + transaction_hash_contains: z.optional(z.string()), + transaction_hash_starts_with: z.optional(z.string()), + transaction_hash_ends_with: z.optional(z.string()), + transaction_hash_like: z.optional(z.string()), + transaction_hash_not_like: z.optional(z.string()), + transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + internal_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + deployer_eq: z.optional(z.string()), + deployer_ne: z.optional(z.string()), + deployer_contains: z.optional(z.string()), + deployer_starts_with: z.optional(z.string()), + deployer_ends_with: z.optional(z.string()), + deployer_like: z.optional(z.string()), + deployer_not_like: z.optional(z.string()), + deployer_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + deployer_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + factory_eq: z.optional(z.string()), + factory_ne: z.optional(z.string()), + factory_contains: z.optional(z.string()), + factory_starts_with: z.optional(z.string()), + factory_ends_with: z.optional(z.string()), + factory_like: z.optional(z.string()), + factory_not_like: z.optional(z.string()), + factory_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + factory_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + init_code_hash_eq: z.optional(z.string()), + init_code_hash_ne: z.optional(z.string()), + init_code_hash_contains: z.optional(z.string()), + init_code_hash_starts_with: z.optional(z.string()), + init_code_hash_ends_with: z.optional(z.string()), + init_code_hash_like: z.optional(z.string()), + init_code_hash_not_like: z.optional(z.string()), + init_code_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + init_code_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractCreationServiceListResponse = zListIntContractCreationResponse; + +export const zIntContractCreationServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractCreationServiceGetResponse = zGetIntContractCreationResponse; + +export const zIntContractSelfdestructServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + internal_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_hash_eq: z.optional(z.string()), + transaction_hash_ne: z.optional(z.string()), + transaction_hash_contains: z.optional(z.string()), + transaction_hash_starts_with: z.optional(z.string()), + transaction_hash_ends_with: z.optional(z.string()), + transaction_hash_like: z.optional(z.string()), + transaction_hash_not_like: z.optional(z.string()), + transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + beneficiary_eq: z.optional(z.string()), + beneficiary_ne: z.optional(z.string()), + beneficiary_contains: z.optional(z.string()), + beneficiary_starts_with: z.optional(z.string()), + beneficiary_ends_with: z.optional(z.string()), + beneficiary_like: z.optional(z.string()), + beneficiary_not_like: z.optional(z.string()), + beneficiary_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + beneficiary_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + value_transferred_eq: z.optional(z.string()), + value_transferred_ne: z.optional(z.string()), + value_transferred_contains: z.optional(z.string()), + value_transferred_starts_with: z.optional(z.string()), + value_transferred_ends_with: z.optional(z.string()), + value_transferred_like: z.optional(z.string()), + value_transferred_not_like: z.optional(z.string()), + value_transferred_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + value_transferred_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + ephemeral_eq: z.optional(z.boolean()), + ephemeral_ne: z.optional(z.boolean()), + storage_cleared_eq: z.optional(z.boolean()), + storage_cleared_ne: z.optional(z.boolean()), + creation_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + creation_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + creation_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + creation_transaction_hash_eq: z.optional(z.string()), + creation_transaction_hash_ne: z.optional(z.string()), + creation_transaction_hash_contains: z.optional(z.string()), + creation_transaction_hash_starts_with: z.optional(z.string()), + creation_transaction_hash_ends_with: z.optional(z.string()), + creation_transaction_hash_like: z.optional(z.string()), + creation_transaction_hash_not_like: z.optional(z.string()), + creation_transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + creation_transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractSelfdestructServiceListResponse = zListIntContractSelfdestructResponse; + +export const zIntContractSelfdestructServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractSelfdestructServiceGetResponse = zGetIntContractSelfdestructResponse; + +export const zIntContractStorageExpiry1mServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractStorageExpiry1mServiceListResponse = zListIntContractStorageExpiry1mResponse; + +export const zIntContractStorageExpiry1mServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractStorageExpiry1mServiceGetResponse = zGetIntContractStorageExpiry1mResponse; + +export const zIntContractStorageExpiry6mServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) ), block_number_lte: z.optional( z @@ -89573,7 +91712,90 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_between_min: z.optional( z .int() .check( @@ -89581,7 +91803,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + touch_block_between_max_value: z.optional( z .int() .check( @@ -89589,7 +91811,9 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -89597,9 +91821,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_eq: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -89607,7 +91829,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_ne: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -89615,7 +91837,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_lt: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -89623,7 +91845,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_lte: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -89631,7 +91853,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_gt: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -89639,7 +91861,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_gte: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -89647,7 +91869,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_between_min: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -89655,17 +91877,215 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_between_max_value: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - internal_index_eq: z.optional( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractStorageExpiry6mServiceListResponse = zListIntContractStorageExpiry6mResponse; + +export const zIntContractStorageExpiry6mServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractStorageExpiry6mServiceGetResponse = zGetIntContractStorageExpiry6mResponse; + +export const zIntContractStorageExpiry12mServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( z .int() .check( @@ -89673,7 +92093,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_ne: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -89681,7 +92101,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_lt: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -89689,7 +92109,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_lte: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -89697,7 +92117,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_gt: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -89705,7 +92125,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_gte: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -89713,7 +92133,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_between_min: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -89721,7 +92141,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_between_max_value: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -89729,8 +92149,8 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), address_eq: z.optional(z.string()), address_ne: z.optional(z.string()), address_contains: z.optional(z.string()), @@ -89740,7 +92160,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ address_not_like: z.optional(z.string()), address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( + touch_block_eq: z.optional( z .int() .check( @@ -89748,7 +92168,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + touch_block_ne: z.optional( z .int() .check( @@ -89756,7 +92176,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + touch_block_lt: z.optional( z .int() .check( @@ -89764,7 +92184,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + touch_block_lte: z.optional( z .int() .check( @@ -89772,7 +92192,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + touch_block_gt: z.optional( z .int() .check( @@ -89780,7 +92200,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + touch_block_gte: z.optional( z .int() .check( @@ -89788,7 +92208,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + touch_block_between_min: z.optional( z .int() .check( @@ -89796,7 +92216,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + touch_block_between_max_value: z.optional( z .int() .check( @@ -89804,40 +92224,9 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_hash_eq: z.optional(z.string()), - transaction_hash_ne: z.optional(z.string()), - transaction_hash_contains: z.optional(z.string()), - transaction_hash_starts_with: z.optional(z.string()), - transaction_hash_ends_with: z.optional(z.string()), - transaction_hash_like: z.optional(z.string()), - transaction_hash_not_like: z.optional(z.string()), - transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - beneficiary_eq: z.optional(z.string()), - beneficiary_ne: z.optional(z.string()), - beneficiary_contains: z.optional(z.string()), - beneficiary_starts_with: z.optional(z.string()), - beneficiary_ends_with: z.optional(z.string()), - beneficiary_like: z.optional(z.string()), - beneficiary_not_like: z.optional(z.string()), - beneficiary_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - beneficiary_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - value_transferred_eq: z.optional(z.string()), - value_transferred_ne: z.optional(z.string()), - value_transferred_contains: z.optional(z.string()), - value_transferred_starts_with: z.optional(z.string()), - value_transferred_ends_with: z.optional(z.string()), - value_transferred_like: z.optional(z.string()), - value_transferred_not_like: z.optional(z.string()), - value_transferred_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - value_transferred_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - ephemeral_eq: z.optional(z.boolean()), - ephemeral_ne: z.optional(z.boolean()), - storage_cleared_eq: z.optional(z.boolean()), - storage_cleared_ne: z.optional(z.boolean()), - creation_block_eq: z.optional( + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -89845,7 +92234,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -89853,7 +92242,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -89861,7 +92250,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -89869,7 +92258,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -89877,7 +92266,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -89885,7 +92274,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -89893,7 +92282,7 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -89901,17 +92290,172 @@ export const zIntContractSelfdestructServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - creation_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - creation_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - creation_transaction_hash_eq: z.optional(z.string()), - creation_transaction_hash_ne: z.optional(z.string()), - creation_transaction_hash_contains: z.optional(z.string()), - creation_transaction_hash_starts_with: z.optional(z.string()), - creation_transaction_hash_ends_with: z.optional(z.string()), - creation_transaction_hash_like: z.optional(z.string()), - creation_transaction_hash_not_like: z.optional(z.string()), - creation_transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - creation_transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -89929,9 +92473,9 @@ export const zIntContractSelfdestructServiceListData = z.object({ /** * OK */ -export const zIntContractSelfdestructServiceListResponse = zListIntContractSelfdestructResponse; +export const zIntContractStorageExpiry12mServiceListResponse = zListIntContractStorageExpiry12mResponse; -export const zIntContractSelfdestructServiceGetData = z.object({ +export const zIntContractStorageExpiry12mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -89947,9 +92491,9 @@ export const zIntContractSelfdestructServiceGetData = z.object({ /** * OK */ -export const zIntContractSelfdestructServiceGetResponse = zGetIntContractSelfdestructResponse; +export const zIntContractStorageExpiry12mServiceGetResponse = zGetIntContractStorageExpiry12mResponse; -export const zIntContractStorageExpiry1mServiceListData = z.object({ +export const zIntContractStorageExpiry18mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -90342,9 +92886,9 @@ export const zIntContractStorageExpiry1mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageExpiry1mServiceListResponse = zListIntContractStorageExpiry1mResponse; +export const zIntContractStorageExpiry18mServiceListResponse = zListIntContractStorageExpiry18mResponse; -export const zIntContractStorageExpiry1mServiceGetData = z.object({ +export const zIntContractStorageExpiry18mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -90360,9 +92904,9 @@ export const zIntContractStorageExpiry1mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageExpiry1mServiceGetResponse = zGetIntContractStorageExpiry1mResponse; +export const zIntContractStorageExpiry18mServiceGetResponse = zGetIntContractStorageExpiry18mResponse; -export const zIntContractStorageExpiry6mServiceListData = z.object({ +export const zIntContractStorageExpiry24mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -90755,9 +93299,9 @@ export const zIntContractStorageExpiry6mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageExpiry6mServiceListResponse = zListIntContractStorageExpiry6mResponse; +export const zIntContractStorageExpiry24mServiceListResponse = zListIntContractStorageExpiry24mResponse; -export const zIntContractStorageExpiry6mServiceGetData = z.object({ +export const zIntContractStorageExpiry24mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -90773,9 +93317,258 @@ export const zIntContractStorageExpiry6mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageExpiry6mServiceGetResponse = zGetIntContractStorageExpiry6mResponse; +export const zIntContractStorageExpiry24mServiceGetResponse = zGetIntContractStorageExpiry24mResponse; -export const zIntContractStorageExpiry12mServiceListData = z.object({ +export const zIntContractStorageNextTouchServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + next_touch_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + next_touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractStorageNextTouchServiceListResponse = zListIntContractStorageNextTouchResponse; + +export const zIntContractStorageNextTouchServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractStorageNextTouchServiceGetResponse = zGetIntContractStorageNextTouchResponse; + +export const zIntContractStorageReactivation1mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -91168,9 +93961,9 @@ export const zIntContractStorageExpiry12mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageExpiry12mServiceListResponse = zListIntContractStorageExpiry12mResponse; +export const zIntContractStorageReactivation1mServiceListResponse = zListIntContractStorageReactivation1mResponse; -export const zIntContractStorageExpiry12mServiceGetData = z.object({ +export const zIntContractStorageReactivation1mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -91186,9 +93979,9 @@ export const zIntContractStorageExpiry12mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageExpiry12mServiceGetResponse = zGetIntContractStorageExpiry12mResponse; +export const zIntContractStorageReactivation1mServiceGetResponse = zGetIntContractStorageReactivation1mResponse; -export const zIntContractStorageExpiry18mServiceListData = z.object({ +export const zIntContractStorageReactivation6mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -91581,9 +94374,9 @@ export const zIntContractStorageExpiry18mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageExpiry18mServiceListResponse = zListIntContractStorageExpiry18mResponse; +export const zIntContractStorageReactivation6mServiceListResponse = zListIntContractStorageReactivation6mResponse; -export const zIntContractStorageExpiry18mServiceGetData = z.object({ +export const zIntContractStorageReactivation6mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -91599,9 +94392,9 @@ export const zIntContractStorageExpiry18mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageExpiry18mServiceGetResponse = zGetIntContractStorageExpiry18mResponse; +export const zIntContractStorageReactivation6mServiceGetResponse = zGetIntContractStorageReactivation6mResponse; -export const zIntContractStorageExpiry24mServiceListData = z.object({ +export const zIntContractStorageReactivation12mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -91994,258 +94787,9 @@ export const zIntContractStorageExpiry24mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageExpiry24mServiceListResponse = zListIntContractStorageExpiry24mResponse; - -export const zIntContractStorageExpiry24mServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntContractStorageExpiry24mServiceGetResponse = zGetIntContractStorageExpiry24mResponse; - -export const zIntContractStorageNextTouchServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - block_number_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - next_touch_block_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - next_touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - next_touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntContractStorageNextTouchServiceListResponse = zListIntContractStorageNextTouchResponse; +export const zIntContractStorageReactivation12mServiceListResponse = zListIntContractStorageReactivation12mResponse; -export const zIntContractStorageNextTouchServiceGetData = z.object({ +export const zIntContractStorageReactivation12mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -92261,9 +94805,9 @@ export const zIntContractStorageNextTouchServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageNextTouchServiceGetResponse = zGetIntContractStorageNextTouchResponse; +export const zIntContractStorageReactivation12mServiceGetResponse = zGetIntContractStorageReactivation12mResponse; -export const zIntContractStorageReactivation1mServiceListData = z.object({ +export const zIntContractStorageReactivation18mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -92656,9 +95200,9 @@ export const zIntContractStorageReactivation1mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageReactivation1mServiceListResponse = zListIntContractStorageReactivation1mResponse; +export const zIntContractStorageReactivation18mServiceListResponse = zListIntContractStorageReactivation18mResponse; -export const zIntContractStorageReactivation1mServiceGetData = z.object({ +export const zIntContractStorageReactivation18mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -92674,9 +95218,9 @@ export const zIntContractStorageReactivation1mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageReactivation1mServiceGetResponse = zGetIntContractStorageReactivation1mResponse; +export const zIntContractStorageReactivation18mServiceGetResponse = zGetIntContractStorageReactivation18mResponse; -export const zIntContractStorageReactivation6mServiceListData = z.object({ +export const zIntContractStorageReactivation24mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -93069,9 +95613,9 @@ export const zIntContractStorageReactivation6mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageReactivation6mServiceListResponse = zListIntContractStorageReactivation6mResponse; +export const zIntContractStorageReactivation24mServiceListResponse = zListIntContractStorageReactivation24mResponse; -export const zIntContractStorageReactivation6mServiceGetData = z.object({ +export const zIntContractStorageReactivation24mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -93087,9 +95631,9 @@ export const zIntContractStorageReactivation6mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageReactivation6mServiceGetResponse = zGetIntContractStorageReactivation6mResponse; +export const zIntContractStorageReactivation24mServiceGetResponse = zGetIntContractStorageReactivation24mResponse; -export const zIntContractStorageReactivation12mServiceListData = z.object({ +export const zIntContractStorageStateServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -93169,7 +95713,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ address_not_like: z.optional(z.string()), address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( + updated_date_time_eq: z.optional( z .int() .check( @@ -93177,7 +95721,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -93185,7 +95729,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -93193,7 +95737,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -93201,7 +95745,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -93209,7 +95753,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -93217,7 +95761,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -93225,7 +95769,7 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -93233,81 +95777,181 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_eq: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gte: z.optional( + slots_delta_gte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_between_min: z.optional( + slots_delta_between_min: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_between_max_value: z.optional( + slots_delta_between_max_value: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93315,9 +95959,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93325,9 +95971,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93335,9 +95983,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93345,9 +95995,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93355,9 +96007,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93365,9 +96019,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93375,21 +96031,25 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), effective_bytes_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93397,9 +96057,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93407,9 +96069,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93417,9 +96081,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93427,9 +96093,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93437,9 +96105,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93447,9 +96117,11 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93457,14 +96129,16 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -93482,9 +96156,9 @@ export const zIntContractStorageReactivation12mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageReactivation12mServiceListResponse = zListIntContractStorageReactivation12mResponse; +export const zIntContractStorageStateServiceListResponse = zListIntContractStorageStateResponse; -export const zIntContractStorageReactivation12mServiceGetData = z.object({ +export const zIntContractStorageStateServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -93500,13 +96174,22 @@ export const zIntContractStorageReactivation12mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageReactivation12mServiceGetResponse = zGetIntContractStorageReactivation12mResponse; +export const zIntContractStorageStateServiceGetResponse = zGetIntContractStorageStateResponse; -export const zIntContractStorageReactivation18mServiceListData = z.object({ +export const zIntContractStorageStateByAddressServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -93573,16 +96256,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( + updated_date_time_eq: z.optional( z .int() .check( @@ -93590,7 +96264,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -93598,7 +96272,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -93606,7 +96280,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -93614,7 +96288,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -93622,7 +96296,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -93630,7 +96304,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -93638,7 +96312,7 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -93646,81 +96320,181 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_eq: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_gte: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_min: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_max_value: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gte: z.optional( - z - .int() + bytes_delta_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_min: z.optional( - z - .int() + bytes_delta_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93728,9 +96502,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93738,9 +96514,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93748,9 +96526,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93758,9 +96538,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93768,9 +96550,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93778,9 +96562,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93788,21 +96574,25 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), effective_bytes_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93810,9 +96600,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93820,9 +96612,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93830,9 +96624,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93840,9 +96636,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93850,9 +96648,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93860,9 +96660,11 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), @@ -93870,14 +96672,16 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -93895,17 +96699,12 @@ export const zIntContractStorageReactivation18mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageReactivation18mServiceListResponse = zListIntContractStorageReactivation18mResponse; +export const zIntContractStorageStateByAddressServiceListResponse = zListIntContractStorageStateByAddressResponse; -export const zIntContractStorageReactivation18mServiceGetData = z.object({ +export const zIntContractStorageStateByAddressServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + address: z.string(), }), query: z.optional(z.never()), }); @@ -93913,9 +96712,9 @@ export const zIntContractStorageReactivation18mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageReactivation18mServiceGetResponse = zGetIntContractStorageReactivation18mResponse; +export const zIntContractStorageStateByAddressServiceGetResponse = zGetIntContractStorageStateByAddressResponse; -export const zIntContractStorageReactivation24mServiceListData = z.object({ +export const zIntContractStorageStateByBlockServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -93986,16 +96785,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( + updated_date_time_eq: z.optional( z .int() .check( @@ -94003,7 +96793,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -94011,7 +96801,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -94019,7 +96809,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -94027,7 +96817,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -94035,7 +96825,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -94043,7 +96833,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -94051,7 +96841,7 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -94059,238 +96849,532 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_eq: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gte: z.optional( + slots_delta_gte: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_min: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_max_value: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + contracts_delta_eq: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_ne: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_lt: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_lte: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_gt: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_gte: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_between_min: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_between_max_value: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + contracts_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + contracts_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_min: z.optional( - z - .int() + active_slots_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + active_slots_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_eq: z.optional( + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_ne: z.optional( + effective_bytes_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_lt: z.optional( + effective_bytes_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_lte: z.optional( + effective_bytes_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_gt: z.optional( + effective_bytes_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_gte: z.optional( + effective_bytes_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_between_min: z.optional( + effective_bytes_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_eq: z.optional( + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_contracts_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_ne: z.optional( + active_contracts_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_lt: z.optional( + active_contracts_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_lte: z.optional( + active_contracts_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_gt: z.optional( + active_contracts_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_gte: z.optional( + active_contracts_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_between_min: z.optional( + active_contracts_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_between_max_value: z.optional( + active_contracts_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_contracts_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_contracts_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -94308,9 +97392,9 @@ export const zIntContractStorageReactivation24mServiceListData = z.object({ /** * OK */ -export const zIntContractStorageReactivation24mServiceListResponse = zListIntContractStorageReactivation24mResponse; +export const zIntContractStorageStateByBlockServiceListResponse = zListIntContractStorageStateByBlockResponse; -export const zIntContractStorageReactivation24mServiceGetData = z.object({ +export const zIntContractStorageStateByBlockServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -94326,13 +97410,22 @@ export const zIntContractStorageReactivation24mServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageReactivation24mServiceGetResponse = zGetIntContractStorageReactivation24mResponse; +export const zIntContractStorageStateByBlockServiceGetResponse = zGetIntContractStorageStateByBlockResponse; -export const zIntContractStorageStateServiceListData = z.object({ +export const zIntContractStorageStateWithExpiryServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + expiry_policy_eq: z.optional(z.string()), + expiry_policy_ne: z.optional(z.string()), + expiry_policy_contains: z.optional(z.string()), + expiry_policy_starts_with: z.optional(z.string()), + expiry_policy_ends_with: z.optional(z.string()), + expiry_policy_like: z.optional(z.string()), + expiry_policy_not_like: z.optional(z.string()), + expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -94474,7 +97567,7 @@ export const zIntContractStorageStateServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( + net_slots_delta_eq: z.optional( z .int() .check( @@ -94482,7 +97575,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_ne: z.optional( + net_slots_delta_ne: z.optional( z .int() .check( @@ -94490,7 +97583,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lt: z.optional( + net_slots_delta_lt: z.optional( z .int() .check( @@ -94498,7 +97591,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lte: z.optional( + net_slots_delta_lte: z.optional( z .int() .check( @@ -94506,7 +97599,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gt: z.optional( + net_slots_delta_gt: z.optional( z .int() .check( @@ -94514,7 +97607,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gte: z.optional( + net_slots_delta_gte: z.optional( z .int() .check( @@ -94522,7 +97615,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_min: z.optional( + net_slots_delta_between_min: z.optional( z .int() .check( @@ -94530,7 +97623,7 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_max_value: z.optional( + net_slots_delta_between_max_value: z.optional( z .int() .check( @@ -94538,9 +97631,9 @@ export const zIntContractStorageStateServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( + net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_eq: z.optional( z.coerce .bigint() .check( @@ -94552,7 +97645,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + net_bytes_delta_ne: z.optional( z.coerce .bigint() .check( @@ -94564,7 +97657,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + net_bytes_delta_lt: z.optional( z.coerce .bigint() .check( @@ -94576,7 +97669,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + net_bytes_delta_lte: z.optional( z.coerce .bigint() .check( @@ -94588,7 +97681,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + net_bytes_delta_gt: z.optional( z.coerce .bigint() .check( @@ -94600,7 +97693,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + net_bytes_delta_gte: z.optional( z.coerce .bigint() .check( @@ -94612,7 +97705,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + net_bytes_delta_between_min: z.optional( z.coerce .bigint() .check( @@ -94624,7 +97717,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_between_max_value: z.optional( + net_bytes_delta_between_max_value: z.optional( z.coerce .bigint() .check( @@ -94636,9 +97729,9 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_eq: z.optional( z.coerce .bigint() .check( @@ -94650,7 +97743,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_ne: z.optional( + cumulative_net_slots_ne: z.optional( z.coerce .bigint() .check( @@ -94662,7 +97755,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_lt: z.optional( + cumulative_net_slots_lt: z.optional( z.coerce .bigint() .check( @@ -94674,7 +97767,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_lte: z.optional( + cumulative_net_slots_lte: z.optional( z.coerce .bigint() .check( @@ -94686,7 +97779,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_gt: z.optional( + cumulative_net_slots_gt: z.optional( z.coerce .bigint() .check( @@ -94698,7 +97791,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_gte: z.optional( + cumulative_net_slots_gte: z.optional( z.coerce .bigint() .check( @@ -94710,7 +97803,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_between_min: z.optional( + cumulative_net_slots_between_min: z.optional( z.coerce .bigint() .check( @@ -94722,7 +97815,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_between_max_value: z.optional( + cumulative_net_slots_between_max_value: z.optional( z.coerce .bigint() .check( @@ -94734,9 +97827,9 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( + cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -94748,7 +97841,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_ne: z.optional( + cumulative_net_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -94760,7 +97853,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_lt: z.optional( + cumulative_net_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -94772,7 +97865,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_lte: z.optional( + cumulative_net_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -94784,7 +97877,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_gt: z.optional( + cumulative_net_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -94796,7 +97889,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_gte: z.optional( + cumulative_net_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -94808,7 +97901,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_between_min: z.optional( + cumulative_net_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -94820,7 +97913,7 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_between_max_value: z.optional( + cumulative_net_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -94832,258 +97925,107 @@ export const zIntContractStorageStateServiceListData = z.object({ }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - page_size: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntContractStorageStateServiceListResponse = zListIntContractStorageStateResponse; - -export const zIntContractStorageStateServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntContractStorageStateServiceGetResponse = zGetIntContractStorageStateResponse; - -export const zIntContractStorageStateByAddressServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_number_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( - z - .int() + cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_ne: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_lt: z.optional( - z - .int() + active_slots_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_lte: z.optional( - z - .int() + active_slots_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_gt: z.optional( - z - .int() + active_slots_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_gte: z.optional( - z - .int() + active_slots_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_between_min: z.optional( - z - .int() + active_slots_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_between_max_value: z.optional( - z - .int() + active_slots_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -95095,7 +98037,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + effective_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -95107,7 +98049,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + effective_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -95119,7 +98061,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + effective_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -95131,7 +98073,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + effective_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -95143,7 +98085,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + effective_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -95155,7 +98097,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + effective_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -95167,7 +98109,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -95179,9 +98121,9 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + prev_active_slots_eq: z.optional( z.coerce .bigint() .check( @@ -95193,7 +98135,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_ne: z.optional( + prev_active_slots_ne: z.optional( z.coerce .bigint() .check( @@ -95205,7 +98147,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_lt: z.optional( + prev_active_slots_lt: z.optional( z.coerce .bigint() .check( @@ -95217,7 +98159,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_lte: z.optional( + prev_active_slots_lte: z.optional( z.coerce .bigint() .check( @@ -95229,7 +98171,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_gt: z.optional( + prev_active_slots_gt: z.optional( z.coerce .bigint() .check( @@ -95241,7 +98183,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_gte: z.optional( + prev_active_slots_gte: z.optional( z.coerce .bigint() .check( @@ -95253,7 +98195,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_between_min: z.optional( + prev_active_slots_between_min: z.optional( z.coerce .bigint() .check( @@ -95265,7 +98207,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_between_max_value: z.optional( + prev_active_slots_between_max_value: z.optional( z.coerce .bigint() .check( @@ -95277,9 +98219,9 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( + prev_active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + prev_active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + prev_effective_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -95291,7 +98233,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_ne: z.optional( + prev_effective_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -95303,7 +98245,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_lt: z.optional( + prev_effective_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -95315,7 +98257,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_lte: z.optional( + prev_effective_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -95327,7 +98269,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_gt: z.optional( + prev_effective_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -95339,7 +98281,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_gte: z.optional( + prev_effective_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -95351,7 +98293,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_between_min: z.optional( + prev_effective_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -95363,7 +98305,7 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_between_max_value: z.optional( + prev_effective_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -95375,8 +98317,8 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + prev_effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + prev_effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -95394,12 +98336,12 @@ export const zIntContractStorageStateByAddressServiceListData = z.object({ /** * OK */ -export const zIntContractStorageStateByAddressServiceListResponse = zListIntContractStorageStateByAddressResponse; +export const zIntContractStorageStateWithExpiryServiceListResponse = zListIntContractStorageStateWithExpiryResponse; -export const zIntContractStorageStateByAddressServiceGetData = z.object({ +export const zIntContractStorageStateWithExpiryServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - address: z.string(), + expiry_policy: z.string(), }), query: z.optional(z.never()), }); @@ -95407,13 +98349,31 @@ export const zIntContractStorageStateByAddressServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageStateByAddressServiceGetResponse = zGetIntContractStorageStateByAddressResponse; +export const zIntContractStorageStateWithExpiryServiceGetResponse = zGetIntContractStorageStateWithExpiryResponse; -export const zIntContractStorageStateByBlockServiceListData = z.object({ +export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_eq: z.optional(z.string()), + expiry_policy_ne: z.optional(z.string()), + expiry_policy_contains: z.optional(z.string()), + expiry_policy_starts_with: z.optional(z.string()), + expiry_policy_ends_with: z.optional(z.string()), + expiry_policy_like: z.optional(z.string()), + expiry_policy_not_like: z.optional(z.string()), + expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -95546,236 +98506,6 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_ne: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_lt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_lte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_gt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_gte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_between_min: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_between_max_value: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - contracts_delta_eq: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_ne: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_lt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_lte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_gt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_gte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_between_min: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_between_max_value: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - contracts_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - contracts_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() @@ -95824,105 +98554,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_slots_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_gt: z.optional( + active_slots_gt: z.optional( z.coerce .bigint() .check( @@ -95934,7 +98566,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - effective_bytes_gte: z.optional( + active_slots_gte: z.optional( z.coerce .bigint() .check( @@ -95946,7 +98578,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - effective_bytes_between_min: z.optional( + active_slots_between_min: z.optional( z.coerce .bigint() .check( @@ -95958,7 +98590,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - effective_bytes_between_max_value: z.optional( + active_slots_between_max_value: z.optional( z.coerce .bigint() .check( @@ -95970,9 +98602,9 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_contracts_eq: z.optional( + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -95984,7 +98616,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_ne: z.optional( + effective_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -95996,7 +98628,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_lt: z.optional( + effective_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -96008,7 +98640,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_lte: z.optional( + effective_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -96020,7 +98652,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_gt: z.optional( + effective_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -96032,7 +98664,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_gte: z.optional( + effective_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -96044,7 +98676,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_between_min: z.optional( + effective_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -96056,7 +98688,7 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -96068,8 +98700,8 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ }) ) ), - active_contracts_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_contracts_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -96087,17 +98719,13 @@ export const zIntContractStorageStateByBlockServiceListData = z.object({ /** * OK */ -export const zIntContractStorageStateByBlockServiceListResponse = zListIntContractStorageStateByBlockResponse; +export const zIntContractStorageStateWithExpiryByAddressServiceListResponse = + zListIntContractStorageStateWithExpiryByAddressResponse; -export const zIntContractStorageStateByBlockServiceGetData = z.object({ +export const zIntContractStorageStateWithExpiryByAddressServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + address: z.string(), }), query: z.optional(z.never()), }); @@ -96105,9 +98733,10 @@ export const zIntContractStorageStateByBlockServiceGetData = z.object({ /** * OK */ -export const zIntContractStorageStateByBlockServiceGetResponse = zGetIntContractStorageStateByBlockResponse; +export const zIntContractStorageStateWithExpiryByAddressServiceGetResponse = + zGetIntContractStorageStateWithExpiryByAddressResponse; -export const zIntContractStorageStateWithExpiryServiceListData = z.object({ +export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -96187,15 +98816,6 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -96262,157 +98882,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - net_slots_delta_eq: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_ne: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_lt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_lte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_gt: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_gte: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_between_min: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_between_max_value: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_between_max_value: z.optional( + active_slots_eq: z.optional( z.coerce .bigint() .check( @@ -96424,9 +98894,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_eq: z.optional( + active_slots_ne: z.optional( z.coerce .bigint() .check( @@ -96438,7 +98906,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_ne: z.optional( + active_slots_lt: z.optional( z.coerce .bigint() .check( @@ -96450,7 +98918,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_lt: z.optional( + active_slots_lte: z.optional( z.coerce .bigint() .check( @@ -96462,7 +98930,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_lte: z.optional( + active_slots_gt: z.optional( z.coerce .bigint() .check( @@ -96474,7 +98942,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_gt: z.optional( + active_slots_gte: z.optional( z.coerce .bigint() .check( @@ -96486,7 +98954,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_gte: z.optional( + active_slots_between_min: z.optional( z.coerce .bigint() .check( @@ -96498,7 +98966,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_between_min: z.optional( + active_slots_between_max_value: z.optional( z.coerce .bigint() .check( @@ -96510,7 +98978,9 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_between_max_value: z.optional( + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -96522,9 +98992,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_eq: z.optional( + effective_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -96536,7 +99004,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_ne: z.optional( + effective_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -96548,7 +99016,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_lt: z.optional( + effective_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -96560,7 +99028,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_lte: z.optional( + effective_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -96572,7 +99040,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_gt: z.optional( + effective_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -96584,7 +99052,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_gte: z.optional( + effective_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -96596,7 +99064,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_between_min: z.optional( + effective_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -96608,7 +99076,9 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_between_max_value: z.optional( + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_contracts_eq: z.optional( z.coerce .bigint() .check( @@ -96620,9 +99090,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + active_contracts_ne: z.optional( z.coerce .bigint() .check( @@ -96634,7 +99102,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_ne: z.optional( + active_contracts_lt: z.optional( z.coerce .bigint() .check( @@ -96646,7 +99114,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_lt: z.optional( + active_contracts_lte: z.optional( z.coerce .bigint() .check( @@ -96658,7 +99126,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_lte: z.optional( + active_contracts_gt: z.optional( z.coerce .bigint() .check( @@ -96670,7 +99138,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_gt: z.optional( + active_contracts_gte: z.optional( z.coerce .bigint() .check( @@ -96682,7 +99150,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_gte: z.optional( + active_contracts_between_min: z.optional( z.coerce .bigint() .check( @@ -96694,7 +99162,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_between_min: z.optional( + active_contracts_between_max_value: z.optional( z.coerce .bigint() .check( @@ -96706,217 +99174,180 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - active_slots_between_max_value: z.optional( - z.coerce - .bigint() + active_contracts_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_contracts_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + page_size: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( - z.coerce - .bigint() + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntContractStorageStateWithExpiryByBlockServiceListResponse = + zListIntContractStorageStateWithExpiryByBlockResponse; + +export const zIntContractStorageStateWithExpiryByBlockServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + expiry_policy: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntContractStorageStateWithExpiryByBlockServiceGetResponse = + zGetIntContractStorageStateWithExpiryByBlockResponse; + +export const zIntCustodyProbeServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + probe_date_time_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_ne: z.optional( - z.coerce - .bigint() + probe_date_time_ne: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_lt: z.optional( - z.coerce - .bigint() + probe_date_time_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_lte: z.optional( - z.coerce - .bigint() + probe_date_time_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_gt: z.optional( - z.coerce - .bigint() + probe_date_time_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_gte: z.optional( - z.coerce - .bigint() + probe_date_time_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_between_min: z.optional( - z.coerce - .bigint() + probe_date_time_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_between_max_value: z.optional( - z.coerce - .bigint() + probe_date_time_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - prev_active_slots_eq: z.optional( - z.coerce - .bigint() + probe_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + probe_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_ne: z.optional( - z.coerce - .bigint() + slot_ne: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_lt: z.optional( - z.coerce - .bigint() + slot_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_lte: z.optional( - z.coerce - .bigint() + slot_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_gt: z.optional( - z.coerce - .bigint() + slot_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_gte: z.optional( - z.coerce - .bigint() + slot_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_between_min: z.optional( - z.coerce - .bigint() + slot_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_between_max_value: z.optional( - z.coerce - .bigint() + slot_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - prev_active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - prev_active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - prev_effective_bytes_eq: z.optional( + slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + peer_id_unique_key_eq: z.optional( z.coerce .bigint() .check( @@ -96928,7 +99359,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_ne: z.optional( + peer_id_unique_key_ne: z.optional( z.coerce .bigint() .check( @@ -96940,7 +99371,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_lt: z.optional( + peer_id_unique_key_lt: z.optional( z.coerce .bigint() .check( @@ -96952,7 +99383,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_lte: z.optional( + peer_id_unique_key_lte: z.optional( z.coerce .bigint() .check( @@ -96964,7 +99395,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_gt: z.optional( + peer_id_unique_key_gt: z.optional( z.coerce .bigint() .check( @@ -96976,7 +99407,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_gte: z.optional( + peer_id_unique_key_gte: z.optional( z.coerce .bigint() .check( @@ -96988,7 +99419,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_between_min: z.optional( + peer_id_unique_key_between_min: z.optional( z.coerce .bigint() .check( @@ -97000,7 +99431,7 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_between_max_value: z.optional( + peer_id_unique_key_between_max_value: z.optional( z.coerce .bigint() .check( @@ -97012,64 +99443,35 @@ export const zIntContractStorageStateWithExpiryServiceListData = z.object({ }) ) ), - prev_effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - prev_effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - page_size: z.optional( + peer_id_unique_key_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + peer_id_unique_key_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + result_eq: z.optional(z.string()), + result_ne: z.optional(z.string()), + result_contains: z.optional(z.string()), + result_starts_with: z.optional(z.string()), + result_ends_with: z.optional(z.string()), + result_like: z.optional(z.string()), + result_not_like: z.optional(z.string()), + result_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + result_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + error_eq: z.optional(z.string()), + error_ne: z.optional(z.string()), + error_contains: z.optional(z.string()), + error_starts_with: z.optional(z.string()), + error_ends_with: z.optional(z.string()), + error_like: z.optional(z.string()), + error_not_like: z.optional(z.string()), + error_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + error_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntContractStorageStateWithExpiryServiceListResponse = zListIntContractStorageStateWithExpiryResponse; - -export const zIntContractStorageStateWithExpiryServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - expiry_policy: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntContractStorageStateWithExpiryServiceGetResponse = zGetIntContractStorageStateWithExpiryResponse; - -export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_eq: z.optional(z.string()), - expiry_policy_ne: z.optional(z.string()), - expiry_policy_contains: z.optional(z.string()), - expiry_policy_starts_with: z.optional(z.string()), - expiry_policy_ends_with: z.optional(z.string()), - expiry_policy_like: z.optional(z.string()), - expiry_policy_not_like: z.optional(z.string()), - expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_number_eq: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -97077,7 +99479,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -97085,7 +99487,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -97093,7 +99495,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -97101,7 +99503,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -97109,7 +99511,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -97117,7 +99519,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -97125,7 +99527,9 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_eq: z.optional( z .int() .check( @@ -97133,9 +99537,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + slot_start_date_time_ne: z.optional( z .int() .check( @@ -97143,7 +99545,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + slot_start_date_time_lt: z.optional( z .int() .check( @@ -97151,7 +99553,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + slot_start_date_time_lte: z.optional( z .int() .check( @@ -97159,7 +99561,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + slot_start_date_time_gt: z.optional( z .int() .check( @@ -97167,7 +99569,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + slot_start_date_time_gte: z.optional( z .int() .check( @@ -97175,7 +99577,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + slot_start_date_time_between_min: z.optional( z .int() .check( @@ -97183,7 +99585,7 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + slot_start_date_time_between_max_value: z.optional( z .int() .check( @@ -97191,7 +99593,43 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + column_indices_has: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + column_indices_has_all_values: z.optional( + z.array( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ) + ), + column_indices_has_any_values: z.optional( + z.array( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ) + ), + column_indices_length_eq: z.optional( z .int() .check( @@ -97199,205 +99637,138 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_eq: z.optional( - z.coerce - .bigint() + column_indices_length_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_ne: z.optional( - z.coerce - .bigint() + column_indices_length_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_lt: z.optional( - z.coerce - .bigint() + column_indices_length_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_lte: z.optional( - z.coerce - .bigint() + column_indices_length_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_gt: z.optional( - z.coerce - .bigint() + blob_submitters_has: z.optional(z.string()), + blob_submitters_has_all_values: z.optional(z.array(z.string())), + blob_submitters_has_any_values: z.optional(z.array(z.string())), + blob_submitters_length_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_gte: z.optional( - z.coerce - .bigint() + blob_submitters_length_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_between_min: z.optional( - z.coerce - .bigint() + blob_submitters_length_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_between_max_value: z.optional( - z.coerce - .bigint() + blob_submitters_length_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( - z.coerce - .bigint() + blob_submitters_length_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_ne: z.optional( - z.coerce - .bigint() + response_time_ms_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_lt: z.optional( - z.coerce - .bigint() + response_time_ms_ne: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_lte: z.optional( - z.coerce - .bigint() + response_time_ms_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_gt: z.optional( - z.coerce - .bigint() + response_time_ms_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_gte: z.optional( - z.coerce - .bigint() + response_time_ms_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_between_min: z.optional( - z.coerce - .bigint() + response_time_ms_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_between_max_value: z.optional( - z.coerce - .bigint() + response_time_ms_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - page_size: z.optional( + response_time_ms_between_max_value: z.optional( z .int() .check( @@ -97405,47 +99776,101 @@ export const zIntContractStorageStateWithExpiryByAddressServiceListData = z.obje z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntContractStorageStateWithExpiryByAddressServiceListResponse = - zListIntContractStorageStateWithExpiryByAddressResponse; - -export const zIntContractStorageStateWithExpiryByAddressServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - address: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntContractStorageStateWithExpiryByAddressServiceGetResponse = - zGetIntContractStorageStateWithExpiryByAddressResponse; - -export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - expiry_policy_eq: z.optional(z.string()), - expiry_policy_ne: z.optional(z.string()), - expiry_policy_contains: z.optional(z.string()), - expiry_policy_starts_with: z.optional(z.string()), - expiry_policy_ends_with: z.optional(z.string()), - expiry_policy_like: z.optional(z.string()), - expiry_policy_not_like: z.optional(z.string()), - expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_number_eq: z.optional( + response_time_ms_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + response_time_ms_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + username_eq: z.optional(z.string()), + username_ne: z.optional(z.string()), + username_contains: z.optional(z.string()), + username_starts_with: z.optional(z.string()), + username_ends_with: z.optional(z.string()), + username_like: z.optional(z.string()), + username_not_like: z.optional(z.string()), + username_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + username_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + node_id_eq: z.optional(z.string()), + node_id_ne: z.optional(z.string()), + node_id_contains: z.optional(z.string()), + node_id_starts_with: z.optional(z.string()), + node_id_ends_with: z.optional(z.string()), + node_id_like: z.optional(z.string()), + node_id_not_like: z.optional(z.string()), + node_id_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + node_id_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + classification_eq: z.optional(z.string()), + classification_ne: z.optional(z.string()), + classification_contains: z.optional(z.string()), + classification_starts_with: z.optional(z.string()), + classification_ends_with: z.optional(z.string()), + classification_like: z.optional(z.string()), + classification_not_like: z.optional(z.string()), + classification_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + classification_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_version_eq: z.optional(z.string()), + meta_client_version_ne: z.optional(z.string()), + meta_client_version_contains: z.optional(z.string()), + meta_client_version_starts_with: z.optional(z.string()), + meta_client_version_ends_with: z.optional(z.string()), + meta_client_version_like: z.optional(z.string()), + meta_client_version_not_like: z.optional(z.string()), + meta_client_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_implementation_eq: z.optional(z.string()), + meta_client_implementation_ne: z.optional(z.string()), + meta_client_implementation_contains: z.optional(z.string()), + meta_client_implementation_starts_with: z.optional(z.string()), + meta_client_implementation_ends_with: z.optional(z.string()), + meta_client_implementation_like: z.optional(z.string()), + meta_client_implementation_not_like: z.optional(z.string()), + meta_client_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_os_eq: z.optional(z.string()), + meta_client_os_ne: z.optional(z.string()), + meta_client_os_contains: z.optional(z.string()), + meta_client_os_starts_with: z.optional(z.string()), + meta_client_os_ends_with: z.optional(z.string()), + meta_client_os_like: z.optional(z.string()), + meta_client_os_not_like: z.optional(z.string()), + meta_client_os_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_os_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_city_eq: z.optional(z.string()), + meta_client_geo_city_ne: z.optional(z.string()), + meta_client_geo_city_contains: z.optional(z.string()), + meta_client_geo_city_starts_with: z.optional(z.string()), + meta_client_geo_city_ends_with: z.optional(z.string()), + meta_client_geo_city_like: z.optional(z.string()), + meta_client_geo_city_not_like: z.optional(z.string()), + meta_client_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_eq: z.optional(z.string()), + meta_client_geo_country_ne: z.optional(z.string()), + meta_client_geo_country_contains: z.optional(z.string()), + meta_client_geo_country_starts_with: z.optional(z.string()), + meta_client_geo_country_ends_with: z.optional(z.string()), + meta_client_geo_country_like: z.optional(z.string()), + meta_client_geo_country_not_like: z.optional(z.string()), + meta_client_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_code_eq: z.optional(z.string()), + meta_client_geo_country_code_ne: z.optional(z.string()), + meta_client_geo_country_code_contains: z.optional(z.string()), + meta_client_geo_country_code_starts_with: z.optional(z.string()), + meta_client_geo_country_code_ends_with: z.optional(z.string()), + meta_client_geo_country_code_like: z.optional(z.string()), + meta_client_geo_country_code_not_like: z.optional(z.string()), + meta_client_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_continent_code_eq: z.optional(z.string()), + meta_client_geo_continent_code_ne: z.optional(z.string()), + meta_client_geo_continent_code_contains: z.optional(z.string()), + meta_client_geo_continent_code_starts_with: z.optional(z.string()), + meta_client_geo_continent_code_ends_with: z.optional(z.string()), + meta_client_geo_continent_code_like: z.optional(z.string()), + meta_client_geo_continent_code_not_like: z.optional(z.string()), + meta_client_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_longitude_value: z.optional(z.number()), + meta_client_geo_latitude_value: z.optional(z.number()), + meta_client_geo_autonomous_system_number_eq: z.optional( z .int() .check( @@ -97453,7 +99878,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + meta_client_geo_autonomous_system_number_ne: z.optional( z .int() .check( @@ -97461,7 +99886,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + meta_client_geo_autonomous_system_number_lt: z.optional( z .int() .check( @@ -97469,7 +99894,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + meta_client_geo_autonomous_system_number_lte: z.optional( z .int() .check( @@ -97477,7 +99902,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + meta_client_geo_autonomous_system_number_gt: z.optional( z .int() .check( @@ -97485,7 +99910,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + meta_client_geo_autonomous_system_number_gte: z.optional( z .int() .check( @@ -97493,7 +99918,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + meta_client_geo_autonomous_system_number_between_min: z.optional( z .int() .check( @@ -97501,7 +99926,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + meta_client_geo_autonomous_system_number_between_max_value: z.optional( z .int() .check( @@ -97509,9 +99934,87 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + meta_client_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_geo_autonomous_system_organization_eq: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_ne: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_contains: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_starts_with: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_ends_with: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_like: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_not_like: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_in_values: z.optional( + z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) + ), + meta_client_geo_autonomous_system_organization_not_in_values: z.optional( + z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) + ), + meta_peer_implementation_eq: z.optional(z.string()), + meta_peer_implementation_ne: z.optional(z.string()), + meta_peer_implementation_contains: z.optional(z.string()), + meta_peer_implementation_starts_with: z.optional(z.string()), + meta_peer_implementation_ends_with: z.optional(z.string()), + meta_peer_implementation_like: z.optional(z.string()), + meta_peer_implementation_not_like: z.optional(z.string()), + meta_peer_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_version_eq: z.optional(z.string()), + meta_peer_version_ne: z.optional(z.string()), + meta_peer_version_contains: z.optional(z.string()), + meta_peer_version_starts_with: z.optional(z.string()), + meta_peer_version_ends_with: z.optional(z.string()), + meta_peer_version_like: z.optional(z.string()), + meta_peer_version_not_like: z.optional(z.string()), + meta_peer_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_platform_eq: z.optional(z.string()), + meta_peer_platform_ne: z.optional(z.string()), + meta_peer_platform_contains: z.optional(z.string()), + meta_peer_platform_starts_with: z.optional(z.string()), + meta_peer_platform_ends_with: z.optional(z.string()), + meta_peer_platform_like: z.optional(z.string()), + meta_peer_platform_not_like: z.optional(z.string()), + meta_peer_platform_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_platform_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_city_eq: z.optional(z.string()), + meta_peer_geo_city_ne: z.optional(z.string()), + meta_peer_geo_city_contains: z.optional(z.string()), + meta_peer_geo_city_starts_with: z.optional(z.string()), + meta_peer_geo_city_ends_with: z.optional(z.string()), + meta_peer_geo_city_like: z.optional(z.string()), + meta_peer_geo_city_not_like: z.optional(z.string()), + meta_peer_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_country_eq: z.optional(z.string()), + meta_peer_geo_country_ne: z.optional(z.string()), + meta_peer_geo_country_contains: z.optional(z.string()), + meta_peer_geo_country_starts_with: z.optional(z.string()), + meta_peer_geo_country_ends_with: z.optional(z.string()), + meta_peer_geo_country_like: z.optional(z.string()), + meta_peer_geo_country_not_like: z.optional(z.string()), + meta_peer_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_country_code_eq: z.optional(z.string()), + meta_peer_geo_country_code_ne: z.optional(z.string()), + meta_peer_geo_country_code_contains: z.optional(z.string()), + meta_peer_geo_country_code_starts_with: z.optional(z.string()), + meta_peer_geo_country_code_ends_with: z.optional(z.string()), + meta_peer_geo_country_code_like: z.optional(z.string()), + meta_peer_geo_country_code_not_like: z.optional(z.string()), + meta_peer_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_continent_code_eq: z.optional(z.string()), + meta_peer_geo_continent_code_ne: z.optional(z.string()), + meta_peer_geo_continent_code_contains: z.optional(z.string()), + meta_peer_geo_continent_code_starts_with: z.optional(z.string()), + meta_peer_geo_continent_code_ends_with: z.optional(z.string()), + meta_peer_geo_continent_code_like: z.optional(z.string()), + meta_peer_geo_continent_code_not_like: z.optional(z.string()), + meta_peer_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_longitude_value: z.optional(z.number()), + meta_peer_geo_latitude_value: z.optional(z.number()), + meta_peer_geo_autonomous_system_number_eq: z.optional( z .int() .check( @@ -97519,7 +100022,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + meta_peer_geo_autonomous_system_number_ne: z.optional( z .int() .check( @@ -97527,7 +100030,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + meta_peer_geo_autonomous_system_number_lt: z.optional( z .int() .check( @@ -97535,7 +100038,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + meta_peer_geo_autonomous_system_number_lte: z.optional( z .int() .check( @@ -97543,7 +100046,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + meta_peer_geo_autonomous_system_number_gt: z.optional( z .int() .check( @@ -97551,7 +100054,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + meta_peer_geo_autonomous_system_number_gte: z.optional( z .int() .check( @@ -97559,7 +100062,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + meta_peer_geo_autonomous_system_number_between_min: z.optional( z .int() .check( @@ -97567,7 +100070,7 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + meta_peer_geo_autonomous_system_number_between_max_value: z.optional( z .int() .check( @@ -97575,302 +100078,19 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - active_slots_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_contracts_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - active_contracts_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) + meta_peer_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_peer_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_peer_geo_autonomous_system_organization_eq: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_ne: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_contains: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_starts_with: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_ends_with: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_like: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_not_like: z.optional(z.string()), + meta_peer_geo_autonomous_system_organization_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_peer_geo_autonomous_system_organization_not_in_values: z.optional( + z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) ), - active_contracts_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_contracts_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -97888,13 +100108,17 @@ export const zIntContractStorageStateWithExpiryByBlockServiceListData = z.object /** * OK */ -export const zIntContractStorageStateWithExpiryByBlockServiceListResponse = - zListIntContractStorageStateWithExpiryByBlockResponse; +export const zIntCustodyProbeServiceListResponse = zListIntCustodyProbeResponse; -export const zIntContractStorageStateWithExpiryByBlockServiceGetData = z.object({ +export const zIntCustodyProbeServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - expiry_policy: z.string(), + probe_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), }), query: z.optional(z.never()), }); @@ -97902,15 +100126,14 @@ export const zIntContractStorageStateWithExpiryByBlockServiceGetData = z.object( /** * OK */ -export const zIntContractStorageStateWithExpiryByBlockServiceGetResponse = - zGetIntContractStorageStateWithExpiryByBlockResponse; +export const zIntCustodyProbeServiceGetResponse = zGetIntCustodyProbeResponse; -export const zIntCustodyProbeServiceListData = z.object({ +export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - probe_date_time_eq: z.optional( + slot_start_date_time_eq: z.optional( z .int() .check( @@ -97918,7 +100141,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_ne: z.optional( + slot_start_date_time_ne: z.optional( z .int() .check( @@ -97926,7 +100149,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_lt: z.optional( + slot_start_date_time_lt: z.optional( z .int() .check( @@ -97934,7 +100157,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_lte: z.optional( + slot_start_date_time_lte: z.optional( z .int() .check( @@ -97942,7 +100165,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_gt: z.optional( + slot_start_date_time_gt: z.optional( z .int() .check( @@ -97950,7 +100173,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_gte: z.optional( + slot_start_date_time_gte: z.optional( z .int() .check( @@ -97958,7 +100181,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_between_min: z.optional( + slot_start_date_time_between_min: z.optional( z .int() .check( @@ -97966,7 +100189,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_between_max_value: z.optional( + slot_start_date_time_between_max_value: z.optional( z .int() .check( @@ -97974,8 +100197,8 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - probe_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), slot_eq: z.optional( z .int() @@ -98224,7 +100447,7 @@ export const zIntCustodyProbeServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_start_date_time_eq: z.optional( + probe_date_time_eq: z.optional( z .int() .check( @@ -98232,7 +100455,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_ne: z.optional( + probe_date_time_ne: z.optional( z .int() .check( @@ -98240,7 +100463,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lt: z.optional( + probe_date_time_lt: z.optional( z .int() .check( @@ -98248,7 +100471,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lte: z.optional( + probe_date_time_lte: z.optional( z .int() .check( @@ -98256,7 +100479,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gt: z.optional( + probe_date_time_gt: z.optional( z .int() .check( @@ -98264,7 +100487,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gte: z.optional( + probe_date_time_gte: z.optional( z .int() .check( @@ -98272,7 +100495,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_min: z.optional( + probe_date_time_between_min: z.optional( z .int() .check( @@ -98280,7 +100503,7 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_max_value: z.optional( + probe_date_time_between_max_value: z.optional( z .int() .check( @@ -98288,8 +100511,8 @@ export const zIntCustodyProbeServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + probe_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + probe_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), column_indices_has: z.optional( z.coerce .bigint() @@ -98803,12 +101026,12 @@ export const zIntCustodyProbeServiceListData = z.object({ /** * OK */ -export const zIntCustodyProbeServiceListResponse = zListIntCustodyProbeResponse; +export const zIntCustodyProbeOrderBySlotServiceListResponse = zListIntCustodyProbeOrderBySlotResponse; -export const zIntCustodyProbeServiceGetData = z.object({ +export const zIntCustodyProbeOrderBySlotServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - probe_date_time: z + slot_start_date_time: z .int() .check( z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), @@ -98821,9 +101044,9 @@ export const zIntCustodyProbeServiceGetData = z.object({ /** * OK */ -export const zIntCustodyProbeServiceGetResponse = zGetIntCustodyProbeResponse; +export const zIntCustodyProbeOrderBySlotServiceGetResponse = zGetIntCustodyProbeOrderBySlotResponse; -export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ +export const zIntEngineGetBlobsServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -98894,7 +101117,123 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ ), slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_eq: z.optional( + block_root_eq: z.optional(z.string()), + block_root_ne: z.optional(z.string()), + block_root_contains: z.optional(z.string()), + block_root_starts_with: z.optional(z.string()), + block_root_ends_with: z.optional(z.string()), + block_root_like: z.optional(z.string()), + block_root_not_like: z.optional(z.string()), + block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_eq: z.optional(z.string()), + meta_client_name_ne: z.optional(z.string()), + meta_client_name_contains: z.optional(z.string()), + meta_client_name_starts_with: z.optional(z.string()), + meta_client_name_ends_with: z.optional(z.string()), + meta_client_name_like: z.optional(z.string()), + meta_client_name_not_like: z.optional(z.string()), + meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + event_date_time_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + event_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + event_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -98902,7 +101241,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -98910,7 +101249,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -98918,7 +101257,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -98926,7 +101265,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -98934,7 +101273,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -98942,7 +101281,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -98950,7 +101289,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -98958,9 +101297,9 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - peer_id_unique_key_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + requested_date_time_eq: z.optional( z.coerce .bigint() .check( @@ -98972,7 +101311,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ }) ) ), - peer_id_unique_key_ne: z.optional( + requested_date_time_ne: z.optional( z.coerce .bigint() .check( @@ -98984,7 +101323,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ }) ) ), - peer_id_unique_key_lt: z.optional( + requested_date_time_lt: z.optional( z.coerce .bigint() .check( @@ -98996,7 +101335,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ }) ) ), - peer_id_unique_key_lte: z.optional( + requested_date_time_lte: z.optional( z.coerce .bigint() .check( @@ -99008,7 +101347,31 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ }) ) ), - peer_id_unique_key_gt: z.optional( + requested_date_time_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + requested_date_time_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + requested_date_time_between_min: z.optional( z.coerce .bigint() .check( @@ -99020,63 +101383,219 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ }) ) ), - peer_id_unique_key_gte: z.optional( - z.coerce - .bigint() + requested_date_time_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + requested_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + requested_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + duration_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + duration_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + duration_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - peer_id_unique_key_between_min: z.optional( - z.coerce - .bigint() + epoch_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - peer_id_unique_key_between_max_value: z.optional( - z.coerce - .bigint() + epoch_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - peer_id_unique_key_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - peer_id_unique_key_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - result_eq: z.optional(z.string()), - result_ne: z.optional(z.string()), - result_contains: z.optional(z.string()), - result_starts_with: z.optional(z.string()), - result_ends_with: z.optional(z.string()), - result_like: z.optional(z.string()), - result_not_like: z.optional(z.string()), - result_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - result_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - error_eq: z.optional(z.string()), - error_ne: z.optional(z.string()), - error_contains: z.optional(z.string()), - error_starts_with: z.optional(z.string()), - error_ends_with: z.optional(z.string()), - error_like: z.optional(z.string()), - error_not_like: z.optional(z.string()), - error_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - error_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( + epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_eq: z.optional( z .int() .check( @@ -99084,7 +101603,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + epoch_start_date_time_ne: z.optional( z .int() .check( @@ -99092,7 +101611,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + epoch_start_date_time_lt: z.optional( z .int() .check( @@ -99100,7 +101619,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + epoch_start_date_time_lte: z.optional( z .int() .check( @@ -99108,7 +101627,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -99116,7 +101635,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -99124,7 +101643,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -99132,7 +101651,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -99140,9 +101659,18 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - probe_date_time_eq: z.optional( + epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_parent_root_eq: z.optional(z.string()), + block_parent_root_ne: z.optional(z.string()), + block_parent_root_contains: z.optional(z.string()), + block_parent_root_starts_with: z.optional(z.string()), + block_parent_root_ends_with: z.optional(z.string()), + block_parent_root_like: z.optional(z.string()), + block_parent_root_not_like: z.optional(z.string()), + block_parent_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_parent_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_index_eq: z.optional( z .int() .check( @@ -99150,7 +101678,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_ne: z.optional( + proposer_index_ne: z.optional( z .int() .check( @@ -99158,7 +101686,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_lt: z.optional( + proposer_index_lt: z.optional( z .int() .check( @@ -99166,7 +101694,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_lte: z.optional( + proposer_index_lte: z.optional( z .int() .check( @@ -99174,7 +101702,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_gt: z.optional( + proposer_index_gt: z.optional( z .int() .check( @@ -99182,7 +101710,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_gte: z.optional( + proposer_index_gte: z.optional( z .int() .check( @@ -99190,7 +101718,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_between_min: z.optional( + proposer_index_between_min: z.optional( z .int() .check( @@ -99198,7 +101726,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_between_max_value: z.optional( + proposer_index_between_max_value: z.optional( z .int() .check( @@ -99206,43 +101734,17 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - probe_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - probe_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - column_indices_has: z.optional( - z.coerce - .bigint() + proposer_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + proposer_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + requested_count_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - column_indices_has_all_values: z.optional( - z.array( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ) - ), - column_indices_has_any_values: z.optional( - z.array( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ) - ), - column_indices_length_eq: z.optional( + requested_count_ne: z.optional( z .int() .check( @@ -99250,7 +101752,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - column_indices_length_gt: z.optional( + requested_count_lt: z.optional( z .int() .check( @@ -99258,7 +101760,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - column_indices_length_gte: z.optional( + requested_count_lte: z.optional( z .int() .check( @@ -99266,7 +101768,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - column_indices_length_lt: z.optional( + requested_count_gt: z.optional( z .int() .check( @@ -99274,7 +101776,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - column_indices_length_lte: z.optional( + requested_count_gte: z.optional( z .int() .check( @@ -99282,10 +101784,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_submitters_has: z.optional(z.string()), - blob_submitters_has_all_values: z.optional(z.array(z.string())), - blob_submitters_has_any_values: z.optional(z.array(z.string())), - blob_submitters_length_eq: z.optional( + requested_count_between_min: z.optional( z .int() .check( @@ -99293,7 +101792,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_submitters_length_gt: z.optional( + requested_count_between_max_value: z.optional( z .int() .check( @@ -99301,7 +101800,12 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_submitters_length_gte: z.optional( + requested_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + requested_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + versioned_hashes_has: z.optional(z.string()), + versioned_hashes_has_all_values: z.optional(z.array(z.string())), + versioned_hashes_has_any_values: z.optional(z.array(z.string())), + versioned_hashes_length_eq: z.optional( z .int() .check( @@ -99309,7 +101813,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_submitters_length_lt: z.optional( + versioned_hashes_length_gt: z.optional( z .int() .check( @@ -99317,7 +101821,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_submitters_length_lte: z.optional( + versioned_hashes_length_gte: z.optional( z .int() .check( @@ -99325,165 +101829,71 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_eq: z.optional( + versioned_hashes_length_lt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_ne: z.optional( + versioned_hashes_length_lte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_lt: z.optional( + returned_count_eq: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_lte: z.optional( + returned_count_ne: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_gt: z.optional( + returned_count_lt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_gte: z.optional( + returned_count_lte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_between_min: z.optional( + returned_count_gt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_between_max_value: z.optional( + returned_count_gte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - response_time_ms_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - response_time_ms_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - username_eq: z.optional(z.string()), - username_ne: z.optional(z.string()), - username_contains: z.optional(z.string()), - username_starts_with: z.optional(z.string()), - username_ends_with: z.optional(z.string()), - username_like: z.optional(z.string()), - username_not_like: z.optional(z.string()), - username_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - username_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - node_id_eq: z.optional(z.string()), - node_id_ne: z.optional(z.string()), - node_id_contains: z.optional(z.string()), - node_id_starts_with: z.optional(z.string()), - node_id_ends_with: z.optional(z.string()), - node_id_like: z.optional(z.string()), - node_id_not_like: z.optional(z.string()), - node_id_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - node_id_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - classification_eq: z.optional(z.string()), - classification_ne: z.optional(z.string()), - classification_contains: z.optional(z.string()), - classification_starts_with: z.optional(z.string()), - classification_ends_with: z.optional(z.string()), - classification_like: z.optional(z.string()), - classification_not_like: z.optional(z.string()), - classification_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - classification_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_version_eq: z.optional(z.string()), - meta_client_version_ne: z.optional(z.string()), - meta_client_version_contains: z.optional(z.string()), - meta_client_version_starts_with: z.optional(z.string()), - meta_client_version_ends_with: z.optional(z.string()), - meta_client_version_like: z.optional(z.string()), - meta_client_version_not_like: z.optional(z.string()), - meta_client_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_implementation_eq: z.optional(z.string()), - meta_client_implementation_ne: z.optional(z.string()), - meta_client_implementation_contains: z.optional(z.string()), - meta_client_implementation_starts_with: z.optional(z.string()), - meta_client_implementation_ends_with: z.optional(z.string()), - meta_client_implementation_like: z.optional(z.string()), - meta_client_implementation_not_like: z.optional(z.string()), - meta_client_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_os_eq: z.optional(z.string()), - meta_client_os_ne: z.optional(z.string()), - meta_client_os_contains: z.optional(z.string()), - meta_client_os_starts_with: z.optional(z.string()), - meta_client_os_ends_with: z.optional(z.string()), - meta_client_os_like: z.optional(z.string()), - meta_client_os_not_like: z.optional(z.string()), - meta_client_os_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_os_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_city_eq: z.optional(z.string()), - meta_client_geo_city_ne: z.optional(z.string()), - meta_client_geo_city_contains: z.optional(z.string()), - meta_client_geo_city_starts_with: z.optional(z.string()), - meta_client_geo_city_ends_with: z.optional(z.string()), - meta_client_geo_city_like: z.optional(z.string()), - meta_client_geo_city_not_like: z.optional(z.string()), - meta_client_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_eq: z.optional(z.string()), - meta_client_geo_country_ne: z.optional(z.string()), - meta_client_geo_country_contains: z.optional(z.string()), - meta_client_geo_country_starts_with: z.optional(z.string()), - meta_client_geo_country_ends_with: z.optional(z.string()), - meta_client_geo_country_like: z.optional(z.string()), - meta_client_geo_country_not_like: z.optional(z.string()), - meta_client_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_code_eq: z.optional(z.string()), - meta_client_geo_country_code_ne: z.optional(z.string()), - meta_client_geo_country_code_contains: z.optional(z.string()), - meta_client_geo_country_code_starts_with: z.optional(z.string()), - meta_client_geo_country_code_ends_with: z.optional(z.string()), - meta_client_geo_country_code_like: z.optional(z.string()), - meta_client_geo_country_code_not_like: z.optional(z.string()), - meta_client_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_continent_code_eq: z.optional(z.string()), - meta_client_geo_continent_code_ne: z.optional(z.string()), - meta_client_geo_continent_code_contains: z.optional(z.string()), - meta_client_geo_continent_code_starts_with: z.optional(z.string()), - meta_client_geo_continent_code_ends_with: z.optional(z.string()), - meta_client_geo_continent_code_like: z.optional(z.string()), - meta_client_geo_continent_code_not_like: z.optional(z.string()), - meta_client_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_longitude_value: z.optional(z.number()), - meta_client_geo_latitude_value: z.optional(z.number()), - meta_client_geo_autonomous_system_number_eq: z.optional( + returned_count_between_min: z.optional( z .int() .check( @@ -99491,7 +101901,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_ne: z.optional( + returned_count_between_max_value: z.optional( z .int() .check( @@ -99499,7 +101909,9 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lt: z.optional( + returned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + returned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + returned_blob_indexes_has: z.optional( z .int() .check( @@ -99507,7 +101919,27 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lte: z.optional( + returned_blob_indexes_has_all_values: z.optional( + z.array( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ) + ), + returned_blob_indexes_has_any_values: z.optional( + z.array( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ) + ), + returned_blob_indexes_length_eq: z.optional( z .int() .check( @@ -99515,7 +101947,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gt: z.optional( + returned_blob_indexes_length_gt: z.optional( z .int() .check( @@ -99523,7 +101955,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gte: z.optional( + returned_blob_indexes_length_gte: z.optional( z .int() .check( @@ -99531,7 +101963,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_min: z.optional( + returned_blob_indexes_length_lt: z.optional( z .int() .check( @@ -99539,7 +101971,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_max_value: z.optional( + returned_blob_indexes_length_lte: z.optional( z .int() .check( @@ -99547,87 +101979,126 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_client_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_client_geo_autonomous_system_organization_eq: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_ne: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_contains: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_starts_with: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_ends_with: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_like: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_not_like: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_in_values: z.optional( - z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) - ), - meta_client_geo_autonomous_system_organization_not_in_values: z.optional( - z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) - ), - meta_peer_implementation_eq: z.optional(z.string()), - meta_peer_implementation_ne: z.optional(z.string()), - meta_peer_implementation_contains: z.optional(z.string()), - meta_peer_implementation_starts_with: z.optional(z.string()), - meta_peer_implementation_ends_with: z.optional(z.string()), - meta_peer_implementation_like: z.optional(z.string()), - meta_peer_implementation_not_like: z.optional(z.string()), - meta_peer_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_version_eq: z.optional(z.string()), - meta_peer_version_ne: z.optional(z.string()), - meta_peer_version_contains: z.optional(z.string()), - meta_peer_version_starts_with: z.optional(z.string()), - meta_peer_version_ends_with: z.optional(z.string()), - meta_peer_version_like: z.optional(z.string()), - meta_peer_version_not_like: z.optional(z.string()), - meta_peer_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_platform_eq: z.optional(z.string()), - meta_peer_platform_ne: z.optional(z.string()), - meta_peer_platform_contains: z.optional(z.string()), - meta_peer_platform_starts_with: z.optional(z.string()), - meta_peer_platform_ends_with: z.optional(z.string()), - meta_peer_platform_like: z.optional(z.string()), - meta_peer_platform_not_like: z.optional(z.string()), - meta_peer_platform_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_platform_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_city_eq: z.optional(z.string()), - meta_peer_geo_city_ne: z.optional(z.string()), - meta_peer_geo_city_contains: z.optional(z.string()), - meta_peer_geo_city_starts_with: z.optional(z.string()), - meta_peer_geo_city_ends_with: z.optional(z.string()), - meta_peer_geo_city_like: z.optional(z.string()), - meta_peer_geo_city_not_like: z.optional(z.string()), - meta_peer_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_country_eq: z.optional(z.string()), - meta_peer_geo_country_ne: z.optional(z.string()), - meta_peer_geo_country_contains: z.optional(z.string()), - meta_peer_geo_country_starts_with: z.optional(z.string()), - meta_peer_geo_country_ends_with: z.optional(z.string()), - meta_peer_geo_country_like: z.optional(z.string()), - meta_peer_geo_country_not_like: z.optional(z.string()), - meta_peer_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_country_code_eq: z.optional(z.string()), - meta_peer_geo_country_code_ne: z.optional(z.string()), - meta_peer_geo_country_code_contains: z.optional(z.string()), - meta_peer_geo_country_code_starts_with: z.optional(z.string()), - meta_peer_geo_country_code_ends_with: z.optional(z.string()), - meta_peer_geo_country_code_like: z.optional(z.string()), - meta_peer_geo_country_code_not_like: z.optional(z.string()), - meta_peer_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_continent_code_eq: z.optional(z.string()), - meta_peer_geo_continent_code_ne: z.optional(z.string()), - meta_peer_geo_continent_code_contains: z.optional(z.string()), - meta_peer_geo_continent_code_starts_with: z.optional(z.string()), - meta_peer_geo_continent_code_ends_with: z.optional(z.string()), - meta_peer_geo_continent_code_like: z.optional(z.string()), - meta_peer_geo_continent_code_not_like: z.optional(z.string()), - meta_peer_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_longitude_value: z.optional(z.number()), - meta_peer_geo_latitude_value: z.optional(z.number()), - meta_peer_geo_autonomous_system_number_eq: z.optional( + status_eq: z.optional(z.string()), + status_ne: z.optional(z.string()), + status_contains: z.optional(z.string()), + status_starts_with: z.optional(z.string()), + status_ends_with: z.optional(z.string()), + status_like: z.optional(z.string()), + status_not_like: z.optional(z.string()), + status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + error_message_eq: z.optional(z.string()), + error_message_ne: z.optional(z.string()), + error_message_contains: z.optional(z.string()), + error_message_starts_with: z.optional(z.string()), + error_message_ends_with: z.optional(z.string()), + error_message_like: z.optional(z.string()), + error_message_not_like: z.optional(z.string()), + error_message_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + error_message_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + method_version_eq: z.optional(z.string()), + method_version_ne: z.optional(z.string()), + method_version_contains: z.optional(z.string()), + method_version_starts_with: z.optional(z.string()), + method_version_ends_with: z.optional(z.string()), + method_version_like: z.optional(z.string()), + method_version_not_like: z.optional(z.string()), + method_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + method_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + source_eq: z.optional(z.string()), + source_ne: z.optional(z.string()), + source_contains: z.optional(z.string()), + source_starts_with: z.optional(z.string()), + source_ends_with: z.optional(z.string()), + source_like: z.optional(z.string()), + source_not_like: z.optional(z.string()), + source_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + source_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + node_class_eq: z.optional(z.string()), + node_class_ne: z.optional(z.string()), + node_class_contains: z.optional(z.string()), + node_class_starts_with: z.optional(z.string()), + node_class_ends_with: z.optional(z.string()), + node_class_like: z.optional(z.string()), + node_class_not_like: z.optional(z.string()), + node_class_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + node_class_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_version_eq: z.optional(z.string()), + meta_execution_version_ne: z.optional(z.string()), + meta_execution_version_contains: z.optional(z.string()), + meta_execution_version_starts_with: z.optional(z.string()), + meta_execution_version_ends_with: z.optional(z.string()), + meta_execution_version_like: z.optional(z.string()), + meta_execution_version_not_like: z.optional(z.string()), + meta_execution_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_implementation_eq: z.optional(z.string()), + meta_execution_implementation_ne: z.optional(z.string()), + meta_execution_implementation_contains: z.optional(z.string()), + meta_execution_implementation_starts_with: z.optional(z.string()), + meta_execution_implementation_ends_with: z.optional(z.string()), + meta_execution_implementation_like: z.optional(z.string()), + meta_execution_implementation_not_like: z.optional(z.string()), + meta_execution_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_implementation_eq: z.optional(z.string()), + meta_client_implementation_ne: z.optional(z.string()), + meta_client_implementation_contains: z.optional(z.string()), + meta_client_implementation_starts_with: z.optional(z.string()), + meta_client_implementation_ends_with: z.optional(z.string()), + meta_client_implementation_like: z.optional(z.string()), + meta_client_implementation_not_like: z.optional(z.string()), + meta_client_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_version_eq: z.optional(z.string()), + meta_client_version_ne: z.optional(z.string()), + meta_client_version_contains: z.optional(z.string()), + meta_client_version_starts_with: z.optional(z.string()), + meta_client_version_ends_with: z.optional(z.string()), + meta_client_version_like: z.optional(z.string()), + meta_client_version_not_like: z.optional(z.string()), + meta_client_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_city_eq: z.optional(z.string()), + meta_client_geo_city_ne: z.optional(z.string()), + meta_client_geo_city_contains: z.optional(z.string()), + meta_client_geo_city_starts_with: z.optional(z.string()), + meta_client_geo_city_ends_with: z.optional(z.string()), + meta_client_geo_city_like: z.optional(z.string()), + meta_client_geo_city_not_like: z.optional(z.string()), + meta_client_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_eq: z.optional(z.string()), + meta_client_geo_country_ne: z.optional(z.string()), + meta_client_geo_country_contains: z.optional(z.string()), + meta_client_geo_country_starts_with: z.optional(z.string()), + meta_client_geo_country_ends_with: z.optional(z.string()), + meta_client_geo_country_like: z.optional(z.string()), + meta_client_geo_country_not_like: z.optional(z.string()), + meta_client_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_code_eq: z.optional(z.string()), + meta_client_geo_country_code_ne: z.optional(z.string()), + meta_client_geo_country_code_contains: z.optional(z.string()), + meta_client_geo_country_code_starts_with: z.optional(z.string()), + meta_client_geo_country_code_ends_with: z.optional(z.string()), + meta_client_geo_country_code_like: z.optional(z.string()), + meta_client_geo_country_code_not_like: z.optional(z.string()), + meta_client_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_continent_code_eq: z.optional(z.string()), + meta_client_geo_continent_code_ne: z.optional(z.string()), + meta_client_geo_continent_code_contains: z.optional(z.string()), + meta_client_geo_continent_code_starts_with: z.optional(z.string()), + meta_client_geo_continent_code_ends_with: z.optional(z.string()), + meta_client_geo_continent_code_like: z.optional(z.string()), + meta_client_geo_continent_code_not_like: z.optional(z.string()), + meta_client_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_geo_latitude_value: z.optional(z.number()), + meta_client_geo_longitude_value: z.optional(z.number()), + meta_client_geo_autonomous_system_number_eq: z.optional( z .int() .check( @@ -99635,7 +102106,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_ne: z.optional( + meta_client_geo_autonomous_system_number_ne: z.optional( z .int() .check( @@ -99643,7 +102114,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_lt: z.optional( + meta_client_geo_autonomous_system_number_lt: z.optional( z .int() .check( @@ -99651,7 +102122,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_lte: z.optional( + meta_client_geo_autonomous_system_number_lte: z.optional( z .int() .check( @@ -99659,7 +102130,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_gt: z.optional( + meta_client_geo_autonomous_system_number_gt: z.optional( z .int() .check( @@ -99667,7 +102138,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_gte: z.optional( + meta_client_geo_autonomous_system_number_gte: z.optional( z .int() .check( @@ -99675,7 +102146,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_between_min: z.optional( + meta_client_geo_autonomous_system_number_between_min: z.optional( z .int() .check( @@ -99683,7 +102154,7 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_between_max_value: z.optional( + meta_client_geo_autonomous_system_number_between_max_value: z.optional( z .int() .check( @@ -99691,17 +102162,19 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_peer_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_peer_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_peer_geo_autonomous_system_organization_eq: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_ne: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_contains: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_starts_with: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_ends_with: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_like: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_not_like: z.optional(z.string()), - meta_peer_geo_autonomous_system_organization_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_peer_geo_autonomous_system_organization_not_in_values: z.optional( + meta_client_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_geo_autonomous_system_organization_eq: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_ne: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_contains: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_starts_with: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_ends_with: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_like: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_not_like: z.optional(z.string()), + meta_client_geo_autonomous_system_organization_in_values: z.optional( + z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) + ), + meta_client_geo_autonomous_system_organization_not_in_values: z.optional( z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) ), page_size: z.optional( @@ -99721,9 +102194,9 @@ export const zIntCustodyProbeOrderBySlotServiceListData = z.object({ /** * OK */ -export const zIntCustodyProbeOrderBySlotServiceListResponse = zListIntCustodyProbeOrderBySlotResponse; +export const zIntEngineGetBlobsServiceListResponse = zListIntEngineGetBlobsResponse; -export const zIntCustodyProbeOrderBySlotServiceGetData = z.object({ +export const zIntEngineGetBlobsServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -99739,9 +102212,9 @@ export const zIntCustodyProbeOrderBySlotServiceGetData = z.object({ /** * OK */ -export const zIntCustodyProbeOrderBySlotServiceGetResponse = zGetIntCustodyProbeOrderBySlotResponse; +export const zIntEngineGetBlobsServiceGetResponse = zGetIntEngineGetBlobsResponse; -export const zIntEngineGetBlobsServiceListData = z.object({ +export const zIntEngineNewPayloadServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -99812,15 +102285,15 @@ export const zIntEngineGetBlobsServiceListData = z.object({ ), slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_root_eq: z.optional(z.string()), - block_root_ne: z.optional(z.string()), - block_root_contains: z.optional(z.string()), - block_root_starts_with: z.optional(z.string()), - block_root_ends_with: z.optional(z.string()), - block_root_like: z.optional(z.string()), - block_root_not_like: z.optional(z.string()), - block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_hash_eq: z.optional(z.string()), + block_hash_ne: z.optional(z.string()), + block_hash_contains: z.optional(z.string()), + block_hash_starts_with: z.optional(z.string()), + block_hash_ends_with: z.optional(z.string()), + block_hash_like: z.optional(z.string()), + block_hash_not_like: z.optional(z.string()), + block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), meta_client_name_eq: z.optional(z.string()), meta_client_name_ne: z.optional(z.string()), meta_client_name_contains: z.optional(z.string()), @@ -100093,67 +102566,83 @@ export const zIntEngineGetBlobsServiceListData = z.object({ requested_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), requested_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), duration_ms_eq: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_ne: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_lt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_lte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_gt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_gte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_between_min: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_between_max_value: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), duration_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), @@ -100356,15 +102845,115 @@ export const zIntEngineGetBlobsServiceListData = z.object({ ), epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_parent_root_eq: z.optional(z.string()), - block_parent_root_ne: z.optional(z.string()), - block_parent_root_contains: z.optional(z.string()), - block_parent_root_starts_with: z.optional(z.string()), - block_parent_root_ends_with: z.optional(z.string()), - block_parent_root_like: z.optional(z.string()), - block_parent_root_not_like: z.optional(z.string()), - block_parent_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_parent_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_eq: z.optional(z.string()), + block_root_ne: z.optional(z.string()), + block_root_contains: z.optional(z.string()), + block_root_starts_with: z.optional(z.string()), + block_root_ends_with: z.optional(z.string()), + block_root_like: z.optional(z.string()), + block_root_not_like: z.optional(z.string()), + block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_number_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + parent_block_root_eq: z.optional(z.string()), + parent_block_root_ne: z.optional(z.string()), + parent_block_root_contains: z.optional(z.string()), + parent_block_root_starts_with: z.optional(z.string()), + parent_block_root_ends_with: z.optional(z.string()), + parent_block_root_like: z.optional(z.string()), + parent_block_root_not_like: z.optional(z.string()), + parent_block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + parent_block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + parent_hash_eq: z.optional(z.string()), + parent_hash_ne: z.optional(z.string()), + parent_hash_contains: z.optional(z.string()), + parent_hash_starts_with: z.optional(z.string()), + parent_hash_ends_with: z.optional(z.string()), + parent_hash_like: z.optional(z.string()), + parent_hash_not_like: z.optional(z.string()), + parent_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + parent_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), proposer_index_eq: z.optional( z .int() @@ -100389,7 +102978,213 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_lte: z.optional( + proposer_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + proposer_index_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + proposer_index_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + proposer_index_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + proposer_index_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + proposer_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + proposer_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_used_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_limit_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_limit_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_limit_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + tx_count_eq: z.optional( z .int() .check( @@ -100397,7 +103192,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_gt: z.optional( + tx_count_ne: z.optional( z .int() .check( @@ -100405,7 +103200,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_gte: z.optional( + tx_count_lt: z.optional( z .int() .check( @@ -100413,7 +103208,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_between_min: z.optional( + tx_count_lte: z.optional( z .int() .check( @@ -100421,7 +103216,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_between_max_value: z.optional( + tx_count_gt: z.optional( z .int() .check( @@ -100429,9 +103224,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - proposer_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - proposer_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - requested_count_eq: z.optional( + tx_count_gte: z.optional( z .int() .check( @@ -100439,7 +103232,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_ne: z.optional( + tx_count_between_min: z.optional( z .int() .check( @@ -100447,7 +103240,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_lt: z.optional( + tx_count_between_max_value: z.optional( z .int() .check( @@ -100455,7 +103248,9 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_lte: z.optional( + tx_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + tx_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + blob_count_eq: z.optional( z .int() .check( @@ -100463,7 +103258,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_gt: z.optional( + blob_count_ne: z.optional( z .int() .check( @@ -100471,7 +103266,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_gte: z.optional( + blob_count_lt: z.optional( z .int() .check( @@ -100479,7 +103274,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_between_min: z.optional( + blob_count_lte: z.optional( z .int() .check( @@ -100487,7 +103282,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_between_max_value: z.optional( + blob_count_gt: z.optional( z .int() .check( @@ -100495,12 +103290,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - requested_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - requested_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - versioned_hashes_has: z.optional(z.string()), - versioned_hashes_has_all_values: z.optional(z.array(z.string())), - versioned_hashes_has_any_values: z.optional(z.array(z.string())), - versioned_hashes_length_eq: z.optional( + blob_count_gte: z.optional( z .int() .check( @@ -100508,7 +103298,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - versioned_hashes_length_gt: z.optional( + blob_count_between_min: z.optional( z .int() .check( @@ -100516,7 +103306,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - versioned_hashes_length_gte: z.optional( + blob_count_between_max_value: z.optional( z .int() .check( @@ -100524,7 +103314,45 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - versioned_hashes_length_lt: z.optional( + blob_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + blob_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + status_eq: z.optional(z.string()), + status_ne: z.optional(z.string()), + status_contains: z.optional(z.string()), + status_starts_with: z.optional(z.string()), + status_ends_with: z.optional(z.string()), + status_like: z.optional(z.string()), + status_not_like: z.optional(z.string()), + status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + validation_error_eq: z.optional(z.string()), + validation_error_ne: z.optional(z.string()), + validation_error_contains: z.optional(z.string()), + validation_error_starts_with: z.optional(z.string()), + validation_error_ends_with: z.optional(z.string()), + validation_error_like: z.optional(z.string()), + validation_error_not_like: z.optional(z.string()), + validation_error_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + validation_error_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + latest_valid_hash_eq: z.optional(z.string()), + latest_valid_hash_ne: z.optional(z.string()), + latest_valid_hash_contains: z.optional(z.string()), + latest_valid_hash_starts_with: z.optional(z.string()), + latest_valid_hash_ends_with: z.optional(z.string()), + latest_valid_hash_like: z.optional(z.string()), + latest_valid_hash_not_like: z.optional(z.string()), + latest_valid_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + latest_valid_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + method_version_eq: z.optional(z.string()), + method_version_ne: z.optional(z.string()), + method_version_contains: z.optional(z.string()), + method_version_starts_with: z.optional(z.string()), + method_version_ends_with: z.optional(z.string()), + method_version_like: z.optional(z.string()), + method_version_not_like: z.optional(z.string()), + method_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + method_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_total_bytes_eq: z.optional( z .int() .check( @@ -100532,7 +103360,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - versioned_hashes_length_lte: z.optional( + block_total_bytes_ne: z.optional( z .int() .check( @@ -100540,7 +103368,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_eq: z.optional( + block_total_bytes_lt: z.optional( z .int() .check( @@ -100548,7 +103376,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_ne: z.optional( + block_total_bytes_lte: z.optional( z .int() .check( @@ -100556,7 +103384,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_lt: z.optional( + block_total_bytes_gt: z.optional( z .int() .check( @@ -100564,7 +103392,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_lte: z.optional( + block_total_bytes_gte: z.optional( z .int() .check( @@ -100572,7 +103400,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_gt: z.optional( + block_total_bytes_between_min: z.optional( z .int() .check( @@ -100580,7 +103408,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_gte: z.optional( + block_total_bytes_between_max_value: z.optional( z .int() .check( @@ -100588,7 +103416,9 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_between_min: z.optional( + block_total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_total_bytes_compressed_eq: z.optional( z .int() .check( @@ -100596,7 +103426,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_between_max_value: z.optional( + block_total_bytes_compressed_ne: z.optional( z .int() .check( @@ -100604,9 +103434,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - returned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - returned_blob_indexes_has: z.optional( + block_total_bytes_compressed_lt: z.optional( z .int() .check( @@ -100614,27 +103442,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_blob_indexes_has_all_values: z.optional( - z.array( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ) - ), - returned_blob_indexes_has_any_values: z.optional( - z.array( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ) - ), - returned_blob_indexes_length_eq: z.optional( + block_total_bytes_compressed_lte: z.optional( z .int() .check( @@ -100642,7 +103450,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_blob_indexes_length_gt: z.optional( + block_total_bytes_compressed_gt: z.optional( z .int() .check( @@ -100650,7 +103458,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_blob_indexes_length_gte: z.optional( + block_total_bytes_compressed_gte: z.optional( z .int() .check( @@ -100658,7 +103466,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_blob_indexes_length_lt: z.optional( + block_total_bytes_compressed_between_min: z.optional( z .int() .check( @@ -100666,7 +103474,7 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - returned_blob_indexes_length_lte: z.optional( + block_total_bytes_compressed_between_max_value: z.optional( z .int() .check( @@ -100674,42 +103482,17 @@ export const zIntEngineGetBlobsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - status_eq: z.optional(z.string()), - status_ne: z.optional(z.string()), - status_contains: z.optional(z.string()), - status_starts_with: z.optional(z.string()), - status_ends_with: z.optional(z.string()), - status_like: z.optional(z.string()), - status_not_like: z.optional(z.string()), - status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - error_message_eq: z.optional(z.string()), - error_message_ne: z.optional(z.string()), - error_message_contains: z.optional(z.string()), - error_message_starts_with: z.optional(z.string()), - error_message_ends_with: z.optional(z.string()), - error_message_like: z.optional(z.string()), - error_message_not_like: z.optional(z.string()), - error_message_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - error_message_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - method_version_eq: z.optional(z.string()), - method_version_ne: z.optional(z.string()), - method_version_contains: z.optional(z.string()), - method_version_starts_with: z.optional(z.string()), - method_version_ends_with: z.optional(z.string()), - method_version_like: z.optional(z.string()), - method_version_not_like: z.optional(z.string()), - method_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - method_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - source_eq: z.optional(z.string()), - source_ne: z.optional(z.string()), - source_contains: z.optional(z.string()), - source_starts_with: z.optional(z.string()), - source_ends_with: z.optional(z.string()), - source_like: z.optional(z.string()), - source_not_like: z.optional(z.string()), - source_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - source_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_total_bytes_compressed_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_total_bytes_compressed_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_version_eq: z.optional(z.string()), + block_version_ne: z.optional(z.string()), + block_version_contains: z.optional(z.string()), + block_version_starts_with: z.optional(z.string()), + block_version_ends_with: z.optional(z.string()), + block_version_like: z.optional(z.string()), + block_version_not_like: z.optional(z.string()), + block_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), node_class_eq: z.optional(z.string()), node_class_ne: z.optional(z.string()), node_class_contains: z.optional(z.string()), @@ -100889,9 +103672,9 @@ export const zIntEngineGetBlobsServiceListData = z.object({ /** * OK */ -export const zIntEngineGetBlobsServiceListResponse = zListIntEngineGetBlobsResponse; +export const zIntEngineNewPayloadServiceListResponse = zListIntEngineNewPayloadResponse; -export const zIntEngineGetBlobsServiceGetData = z.object({ +export const zIntEngineNewPayloadServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -100907,9 +103690,9 @@ export const zIntEngineGetBlobsServiceGetData = z.object({ /** * OK */ -export const zIntEngineGetBlobsServiceGetResponse = zGetIntEngineGetBlobsResponse; +export const zIntEngineNewPayloadServiceGetResponse = zGetIntEngineNewPayloadResponse; -export const zIntEngineNewPayloadServiceListData = z.object({ +export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -100980,123 +103763,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ ), slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_hash_eq: z.optional(z.string()), - block_hash_ne: z.optional(z.string()), - block_hash_contains: z.optional(z.string()), - block_hash_starts_with: z.optional(z.string()), - block_hash_ends_with: z.optional(z.string()), - block_hash_like: z.optional(z.string()), - block_hash_not_like: z.optional(z.string()), - block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_name_eq: z.optional(z.string()), - meta_client_name_ne: z.optional(z.string()), - meta_client_name_contains: z.optional(z.string()), - meta_client_name_starts_with: z.optional(z.string()), - meta_client_name_ends_with: z.optional(z.string()), - meta_client_name_like: z.optional(z.string()), - meta_client_name_not_like: z.optional(z.string()), - meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - event_date_time_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - event_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - event_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - updated_date_time_eq: z.optional( + slot_eq: z.optional( z .int() .check( @@ -101104,7 +103771,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + slot_ne: z.optional( z .int() .check( @@ -101112,7 +103779,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + slot_lt: z.optional( z .int() .check( @@ -101120,7 +103787,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + slot_lte: z.optional( z .int() .check( @@ -101128,7 +103795,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + slot_gt: z.optional( z .int() .check( @@ -101136,7 +103803,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + slot_gte: z.optional( z .int() .check( @@ -101144,7 +103811,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + slot_between_min: z.optional( z .int() .check( @@ -101152,7 +103819,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + slot_between_max_value: z.optional( z .int() .check( @@ -101160,189 +103827,18 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - requested_date_time_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - requested_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - requested_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - duration_ms_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - duration_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_eq: z.optional( + slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_class_eq: z.optional(z.string()), + node_class_ne: z.optional(z.string()), + node_class_contains: z.optional(z.string()), + node_class_starts_with: z.optional(z.string()), + node_class_ends_with: z.optional(z.string()), + node_class_like: z.optional(z.string()), + node_class_not_like: z.optional(z.string()), + node_class_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + node_class_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -101350,7 +103846,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -101358,7 +103854,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -101366,7 +103862,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -101374,7 +103870,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -101382,7 +103878,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -101390,7 +103886,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -101398,7 +103894,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -101406,8 +103902,8 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), epoch_eq: z.optional( z .int() @@ -101540,16 +104036,16 @@ export const zIntEngineNewPayloadServiceListData = z.object({ ), epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_root_eq: z.optional(z.string()), - block_root_ne: z.optional(z.string()), - block_root_contains: z.optional(z.string()), - block_root_starts_with: z.optional(z.string()), - block_root_ends_with: z.optional(z.string()), - block_root_like: z.optional(z.string()), - block_root_not_like: z.optional(z.string()), - block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_number_eq: z.optional( + block_hash_eq: z.optional(z.string()), + block_hash_ne: z.optional(z.string()), + block_hash_contains: z.optional(z.string()), + block_hash_starts_with: z.optional(z.string()), + block_hash_ends_with: z.optional(z.string()), + block_hash_like: z.optional(z.string()), + block_hash_not_like: z.optional(z.string()), + block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + duration_ms_eq: z.optional( z.coerce .bigint() .check( @@ -101559,7 +104055,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_ne: z.optional( + duration_ms_ne: z.optional( z.coerce .bigint() .check( @@ -101569,7 +104065,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_lt: z.optional( + duration_ms_lt: z.optional( z.coerce .bigint() .check( @@ -101579,7 +104075,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_lte: z.optional( + duration_ms_lte: z.optional( z.coerce .bigint() .check( @@ -101589,7 +104085,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_gt: z.optional( + duration_ms_gt: z.optional( z.coerce .bigint() .check( @@ -101599,7 +104095,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_gte: z.optional( + duration_ms_gte: z.optional( z.coerce .bigint() .check( @@ -101609,7 +104105,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_between_min: z.optional( + duration_ms_between_min: z.optional( z.coerce .bigint() .check( @@ -101619,7 +104115,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_between_max_value: z.optional( + duration_ms_between_max_value: z.optional( z.coerce .bigint() .check( @@ -101629,143 +104125,178 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - parent_block_root_eq: z.optional(z.string()), - parent_block_root_ne: z.optional(z.string()), - parent_block_root_contains: z.optional(z.string()), - parent_block_root_starts_with: z.optional(z.string()), - parent_block_root_ends_with: z.optional(z.string()), - parent_block_root_like: z.optional(z.string()), - parent_block_root_not_like: z.optional(z.string()), - parent_block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - parent_block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - parent_hash_eq: z.optional(z.string()), - parent_hash_ne: z.optional(z.string()), - parent_hash_contains: z.optional(z.string()), - parent_hash_starts_with: z.optional(z.string()), - parent_hash_ends_with: z.optional(z.string()), - parent_hash_like: z.optional(z.string()), - parent_hash_not_like: z.optional(z.string()), - parent_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - parent_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_index_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - proposer_index_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - proposer_index_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - proposer_index_lte: z.optional( + duration_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + duration_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_execution_implementation_eq: z.optional(z.string()), + meta_execution_implementation_ne: z.optional(z.string()), + meta_execution_implementation_contains: z.optional(z.string()), + meta_execution_implementation_starts_with: z.optional(z.string()), + meta_execution_implementation_ends_with: z.optional(z.string()), + meta_execution_implementation_like: z.optional(z.string()), + meta_execution_implementation_not_like: z.optional(z.string()), + meta_execution_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_version_eq: z.optional(z.string()), + meta_execution_version_ne: z.optional(z.string()), + meta_execution_version_contains: z.optional(z.string()), + meta_execution_version_starts_with: z.optional(z.string()), + meta_execution_version_ends_with: z.optional(z.string()), + meta_execution_version_like: z.optional(z.string()), + meta_execution_version_not_like: z.optional(z.string()), + meta_execution_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_execution_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_eq: z.optional(z.string()), + meta_client_name_ne: z.optional(z.string()), + meta_client_name_contains: z.optional(z.string()), + meta_client_name_starts_with: z.optional(z.string()), + meta_client_name_ends_with: z.optional(z.string()), + meta_client_name_like: z.optional(z.string()), + meta_client_name_not_like: z.optional(z.string()), + meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + page_size: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - proposer_index_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListResponse = + zListIntEngineNewPayloadFastestExecutionByNodeClassResponse; + +export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + slot_start_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ), - proposer_index_gte: z.optional( - z - .int() + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceGetResponse = + zGetIntEngineNewPayloadFastestExecutionByNodeClassResponse; + +export const zIntExecutionBlockByDateServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_date_time_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - proposer_index_between_min: z.optional( - z - .int() + block_date_time_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - proposer_index_between_max_value: z.optional( - z - .int() + block_date_time_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - proposer_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - proposer_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_used_eq: z.optional( + block_date_time_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - gas_used_ne: z.optional( + block_date_time_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - gas_used_lt: z.optional( + block_date_time_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - gas_used_lte: z.optional( + block_date_time_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - gas_used_gt: z.optional( + block_date_time_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', }) ) ), - gas_used_gte: z.optional( + block_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + block_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + block_number_eq: z.optional( z.coerce .bigint() .check( @@ -101775,7 +104306,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_used_between_min: z.optional( + block_number_ne: z.optional( z.coerce .bigint() .check( @@ -101785,7 +104316,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_used_between_max_value: z.optional( + block_number_lt: z.optional( z.coerce .bigint() .check( @@ -101795,9 +104326,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_limit_eq: z.optional( + block_number_lte: z.optional( z.coerce .bigint() .check( @@ -101807,7 +104336,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_limit_ne: z.optional( + block_number_gt: z.optional( z.coerce .bigint() .check( @@ -101817,7 +104346,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_limit_lt: z.optional( + block_number_gte: z.optional( z.coerce .bigint() .check( @@ -101827,7 +104356,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_limit_lte: z.optional( + block_number_between_min: z.optional( z.coerce .bigint() .check( @@ -101837,7 +104366,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_limit_gt: z.optional( + block_number_between_max_value: z.optional( z.coerce .bigint() .check( @@ -101847,39 +104376,252 @@ export const zIntEngineNewPayloadServiceListData = z.object({ }) ) ), - gas_limit_gte: z.optional( - z.coerce - .bigint() + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntExecutionBlockByDateServiceListResponse = zListIntExecutionBlockByDateResponse; + +export const zIntExecutionBlockByDateServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_date_time: z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntExecutionBlockByDateServiceGetResponse = zGetIntExecutionBlockByDateResponse; + +export const zIntStorageSelfdestructDiffsServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_hash_eq: z.optional(z.string()), + transaction_hash_ne: z.optional(z.string()), + transaction_hash_contains: z.optional(z.string()), + transaction_hash_starts_with: z.optional(z.string()), + transaction_hash_ends_with: z.optional(z.string()), + transaction_hash_like: z.optional(z.string()), + transaction_hash_not_like: z.optional(z.string()), + transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + internal_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + internal_index_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - gas_limit_between_min: z.optional( - z.coerce - .bigint() + internal_index_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - gas_limit_between_max_value: z.optional( - z.coerce - .bigint() + internal_index_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - gas_limit_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_limit_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - tx_count_eq: z.optional( + internal_index_between_max_value: z.optional( z .int() .check( @@ -101887,7 +104629,18 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_ne: z.optional( + internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_eq: z.optional(z.string()), + slot_ne: z.optional(z.string()), + slot_contains: z.optional(z.string()), + slot_starts_with: z.optional(z.string()), + slot_ends_with: z.optional(z.string()), + slot_like: z.optional(z.string()), + slot_not_like: z.optional(z.string()), + slot_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -101895,7 +104648,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_lt: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -101903,7 +104656,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_lte: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -101911,7 +104664,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_gt: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -101919,7 +104672,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_gte: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -101927,7 +104680,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_between_min: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -101935,7 +104688,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_between_max_value: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -101943,9 +104696,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - tx_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - tx_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - blob_count_eq: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -101953,7 +104704,9 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_ne: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_eq: z.optional( z .int() .check( @@ -101961,7 +104714,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_lt: z.optional( + transaction_index_ne: z.optional( z .int() .check( @@ -101969,7 +104722,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_lte: z.optional( + transaction_index_lt: z.optional( z .int() .check( @@ -101977,7 +104730,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_gt: z.optional( + transaction_index_lte: z.optional( z .int() .check( @@ -101985,7 +104738,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_gte: z.optional( + transaction_index_gt: z.optional( z .int() .check( @@ -101993,7 +104746,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_between_min: z.optional( + transaction_index_gte: z.optional( z .int() .check( @@ -102001,7 +104754,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_between_max_value: z.optional( + transaction_index_between_min: z.optional( z .int() .check( @@ -102009,45 +104762,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - blob_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - status_eq: z.optional(z.string()), - status_ne: z.optional(z.string()), - status_contains: z.optional(z.string()), - status_starts_with: z.optional(z.string()), - status_ends_with: z.optional(z.string()), - status_like: z.optional(z.string()), - status_not_like: z.optional(z.string()), - status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - validation_error_eq: z.optional(z.string()), - validation_error_ne: z.optional(z.string()), - validation_error_contains: z.optional(z.string()), - validation_error_starts_with: z.optional(z.string()), - validation_error_ends_with: z.optional(z.string()), - validation_error_like: z.optional(z.string()), - validation_error_not_like: z.optional(z.string()), - validation_error_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - validation_error_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - latest_valid_hash_eq: z.optional(z.string()), - latest_valid_hash_ne: z.optional(z.string()), - latest_valid_hash_contains: z.optional(z.string()), - latest_valid_hash_starts_with: z.optional(z.string()), - latest_valid_hash_ends_with: z.optional(z.string()), - latest_valid_hash_like: z.optional(z.string()), - latest_valid_hash_not_like: z.optional(z.string()), - latest_valid_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - latest_valid_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - method_version_eq: z.optional(z.string()), - method_version_ne: z.optional(z.string()), - method_version_contains: z.optional(z.string()), - method_version_starts_with: z.optional(z.string()), - method_version_ends_with: z.optional(z.string()), - method_version_like: z.optional(z.string()), - method_version_not_like: z.optional(z.string()), - method_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - method_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_total_bytes_eq: z.optional( + transaction_index_between_max_value: z.optional( z .int() .check( @@ -102055,7 +104770,78 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_ne: z.optional( + transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + from_value_eq: z.optional(z.string()), + from_value_ne: z.optional(z.string()), + from_value_contains: z.optional(z.string()), + from_value_starts_with: z.optional(z.string()), + from_value_ends_with: z.optional(z.string()), + from_value_like: z.optional(z.string()), + from_value_not_like: z.optional(z.string()), + from_value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + from_value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + to_value_eq: z.optional(z.string()), + to_value_ne: z.optional(z.string()), + to_value_contains: z.optional(z.string()), + to_value_starts_with: z.optional(z.string()), + to_value_ends_with: z.optional(z.string()), + to_value_like: z.optional(z.string()), + to_value_not_like: z.optional(z.string()), + to_value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + to_value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntStorageSelfdestructDiffsServiceListResponse = zListIntStorageSelfdestructDiffsResponse; + +export const zIntStorageSelfdestructDiffsServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntStorageSelfdestructDiffsServiceGetResponse = zGetIntStorageSelfdestructDiffsResponse; + +export const zIntStorageSlotDiffServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( z .int() .check( @@ -102063,7 +104849,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_lt: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -102071,7 +104857,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_lte: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -102079,7 +104865,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_gt: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -102087,7 +104873,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_gte: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -102095,7 +104881,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_between_min: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -102103,7 +104889,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_between_max_value: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -102111,9 +104897,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_total_bytes_compressed_eq: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -102121,7 +104905,27 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_ne: z.optional( + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -102129,7 +104933,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_lt: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -102137,7 +104941,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_lte: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -102145,7 +104949,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_gt: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -102153,7 +104957,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_gte: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -102161,7 +104965,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_between_min: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -102169,7 +104973,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_between_max_value: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -102177,101 +104981,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_total_bytes_compressed_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_total_bytes_compressed_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_version_eq: z.optional(z.string()), - block_version_ne: z.optional(z.string()), - block_version_contains: z.optional(z.string()), - block_version_starts_with: z.optional(z.string()), - block_version_ends_with: z.optional(z.string()), - block_version_like: z.optional(z.string()), - block_version_not_like: z.optional(z.string()), - block_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - node_class_eq: z.optional(z.string()), - node_class_ne: z.optional(z.string()), - node_class_contains: z.optional(z.string()), - node_class_starts_with: z.optional(z.string()), - node_class_ends_with: z.optional(z.string()), - node_class_like: z.optional(z.string()), - node_class_not_like: z.optional(z.string()), - node_class_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - node_class_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_version_eq: z.optional(z.string()), - meta_execution_version_ne: z.optional(z.string()), - meta_execution_version_contains: z.optional(z.string()), - meta_execution_version_starts_with: z.optional(z.string()), - meta_execution_version_ends_with: z.optional(z.string()), - meta_execution_version_like: z.optional(z.string()), - meta_execution_version_not_like: z.optional(z.string()), - meta_execution_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_implementation_eq: z.optional(z.string()), - meta_execution_implementation_ne: z.optional(z.string()), - meta_execution_implementation_contains: z.optional(z.string()), - meta_execution_implementation_starts_with: z.optional(z.string()), - meta_execution_implementation_ends_with: z.optional(z.string()), - meta_execution_implementation_like: z.optional(z.string()), - meta_execution_implementation_not_like: z.optional(z.string()), - meta_execution_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_implementation_eq: z.optional(z.string()), - meta_client_implementation_ne: z.optional(z.string()), - meta_client_implementation_contains: z.optional(z.string()), - meta_client_implementation_starts_with: z.optional(z.string()), - meta_client_implementation_ends_with: z.optional(z.string()), - meta_client_implementation_like: z.optional(z.string()), - meta_client_implementation_not_like: z.optional(z.string()), - meta_client_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_version_eq: z.optional(z.string()), - meta_client_version_ne: z.optional(z.string()), - meta_client_version_contains: z.optional(z.string()), - meta_client_version_starts_with: z.optional(z.string()), - meta_client_version_ends_with: z.optional(z.string()), - meta_client_version_like: z.optional(z.string()), - meta_client_version_not_like: z.optional(z.string()), - meta_client_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_city_eq: z.optional(z.string()), - meta_client_geo_city_ne: z.optional(z.string()), - meta_client_geo_city_contains: z.optional(z.string()), - meta_client_geo_city_starts_with: z.optional(z.string()), - meta_client_geo_city_ends_with: z.optional(z.string()), - meta_client_geo_city_like: z.optional(z.string()), - meta_client_geo_city_not_like: z.optional(z.string()), - meta_client_geo_city_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_city_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_eq: z.optional(z.string()), - meta_client_geo_country_ne: z.optional(z.string()), - meta_client_geo_country_contains: z.optional(z.string()), - meta_client_geo_country_starts_with: z.optional(z.string()), - meta_client_geo_country_ends_with: z.optional(z.string()), - meta_client_geo_country_like: z.optional(z.string()), - meta_client_geo_country_not_like: z.optional(z.string()), - meta_client_geo_country_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_code_eq: z.optional(z.string()), - meta_client_geo_country_code_ne: z.optional(z.string()), - meta_client_geo_country_code_contains: z.optional(z.string()), - meta_client_geo_country_code_starts_with: z.optional(z.string()), - meta_client_geo_country_code_ends_with: z.optional(z.string()), - meta_client_geo_country_code_like: z.optional(z.string()), - meta_client_geo_country_code_not_like: z.optional(z.string()), - meta_client_geo_country_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_country_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_continent_code_eq: z.optional(z.string()), - meta_client_geo_continent_code_ne: z.optional(z.string()), - meta_client_geo_continent_code_contains: z.optional(z.string()), - meta_client_geo_continent_code_starts_with: z.optional(z.string()), - meta_client_geo_continent_code_ends_with: z.optional(z.string()), - meta_client_geo_continent_code_like: z.optional(z.string()), - meta_client_geo_continent_code_not_like: z.optional(z.string()), - meta_client_geo_continent_code_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_continent_code_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_geo_latitude_value: z.optional(z.number()), - meta_client_geo_longitude_value: z.optional(z.number()), - meta_client_geo_autonomous_system_number_eq: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -102279,7 +104989,9 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_ne: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_from_eq: z.optional( z .int() .check( @@ -102287,7 +104999,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lt: z.optional( + effective_bytes_from_ne: z.optional( z .int() .check( @@ -102295,7 +105007,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lte: z.optional( + effective_bytes_from_lt: z.optional( z .int() .check( @@ -102303,7 +105015,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gt: z.optional( + effective_bytes_from_lte: z.optional( z .int() .check( @@ -102311,7 +105023,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gte: z.optional( + effective_bytes_from_gt: z.optional( z .int() .check( @@ -102319,7 +105031,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_min: z.optional( + effective_bytes_from_gte: z.optional( z .int() .check( @@ -102327,7 +105039,7 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_max_value: z.optional( + effective_bytes_from_between_min: z.optional( z .int() .check( @@ -102335,64 +105047,17 @@ export const zIntEngineNewPayloadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_client_geo_autonomous_system_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_client_geo_autonomous_system_organization_eq: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_ne: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_contains: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_starts_with: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_ends_with: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_like: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_not_like: z.optional(z.string()), - meta_client_geo_autonomous_system_organization_in_values: z.optional( - z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) - ), - meta_client_geo_autonomous_system_organization_not_in_values: z.optional( - z.string().check(z.regex(/^[^,]+(,[^,]+)*$/)) - ), - page_size: z.optional( + effective_bytes_from_between_max_value: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntEngineNewPayloadServiceListResponse = zListIntEngineNewPayloadResponse; - -export const zIntEngineNewPayloadServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - slot_start_date_time: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntEngineNewPayloadServiceGetResponse = zGetIntEngineNewPayloadResponse; - -export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - slot_start_date_time_eq: z.optional( + effective_bytes_from_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_from_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_to_eq: z.optional( z .int() .check( @@ -102400,7 +105065,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_ne: z.optional( + effective_bytes_to_ne: z.optional( z .int() .check( @@ -102408,7 +105073,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lt: z.optional( + effective_bytes_to_lt: z.optional( z .int() .check( @@ -102416,7 +105081,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lte: z.optional( + effective_bytes_to_lte: z.optional( z .int() .check( @@ -102424,7 +105089,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gt: z.optional( + effective_bytes_to_gt: z.optional( z .int() .check( @@ -102432,7 +105097,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gte: z.optional( + effective_bytes_to_gte: z.optional( z .int() .check( @@ -102440,7 +105105,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_min: z.optional( + effective_bytes_to_between_min: z.optional( z .int() .check( @@ -102448,7 +105113,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_max_value: z.optional( + effective_bytes_to_between_max_value: z.optional( z .int() .check( @@ -102456,9 +105121,69 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_eq: z.optional( + effective_bytes_to_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_to_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntStorageSlotDiffServiceListResponse = zListIntStorageSlotDiffResponse; + +export const zIntStorageSlotDiffServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntStorageSlotDiffServiceGetResponse = zGetIntStorageSlotDiffResponse; + +export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_number_eq: z.optional( z .int() .check( @@ -102466,7 +105191,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_ne: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -102474,7 +105199,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lt: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -102482,7 +105207,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lte: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -102490,7 +105215,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gt: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -102498,7 +105223,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gte: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -102506,7 +105231,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_min: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -102514,7 +105239,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_max_value: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -102522,17 +105247,8 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - node_class_eq: z.optional(z.string()), - node_class_ne: z.optional(z.string()), - node_class_contains: z.optional(z.string()), - node_class_starts_with: z.optional(z.string()), - node_class_ends_with: z.optional(z.string()), - node_class_like: z.optional(z.string()), - node_class_not_like: z.optional(z.string()), - node_class_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - node_class_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -102599,7 +105315,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - epoch_eq: z.optional( + effective_bytes_from_eq: z.optional( z .int() .check( @@ -102607,7 +105323,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_ne: z.optional( + effective_bytes_from_ne: z.optional( z .int() .check( @@ -102615,7 +105331,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lt: z.optional( + effective_bytes_from_lt: z.optional( z .int() .check( @@ -102623,7 +105339,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + effective_bytes_from_lte: z.optional( z .int() .check( @@ -102631,7 +105347,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + effective_bytes_from_gt: z.optional( z .int() .check( @@ -102639,7 +105355,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + effective_bytes_from_gte: z.optional( z .int() .check( @@ -102647,7 +105363,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + effective_bytes_from_between_min: z.optional( z .int() .check( @@ -102655,7 +105371,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + effective_bytes_from_between_max_value: z.optional( z .int() .check( @@ -102663,9 +105379,9 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - epoch_start_date_time_eq: z.optional( + effective_bytes_from_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_from_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_to_eq: z.optional( z .int() .check( @@ -102673,7 +105389,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: z.optional( + effective_bytes_to_ne: z.optional( z .int() .check( @@ -102681,7 +105397,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lt: z.optional( + effective_bytes_to_lt: z.optional( z .int() .check( @@ -102689,7 +105405,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: z.optional( + effective_bytes_to_lte: z.optional( z .int() .check( @@ -102697,7 +105413,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + effective_bytes_to_gt: z.optional( z .int() .check( @@ -102705,7 +105421,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + effective_bytes_to_gte: z.optional( z .int() .check( @@ -102713,7 +105429,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + effective_bytes_to_between_min: z.optional( z .int() .check( @@ -102721,7 +105437,7 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + effective_bytes_to_between_max_value: z.optional( z .int() .check( @@ -102729,126 +105445,8 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_hash_eq: z.optional(z.string()), - block_hash_ne: z.optional(z.string()), - block_hash_contains: z.optional(z.string()), - block_hash_starts_with: z.optional(z.string()), - block_hash_ends_with: z.optional(z.string()), - block_hash_like: z.optional(z.string()), - block_hash_not_like: z.optional(z.string()), - block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - duration_ms_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - duration_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - duration_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - meta_execution_implementation_eq: z.optional(z.string()), - meta_execution_implementation_ne: z.optional(z.string()), - meta_execution_implementation_contains: z.optional(z.string()), - meta_execution_implementation_starts_with: z.optional(z.string()), - meta_execution_implementation_ends_with: z.optional(z.string()), - meta_execution_implementation_like: z.optional(z.string()), - meta_execution_implementation_not_like: z.optional(z.string()), - meta_execution_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_version_eq: z.optional(z.string()), - meta_execution_version_ne: z.optional(z.string()), - meta_execution_version_contains: z.optional(z.string()), - meta_execution_version_starts_with: z.optional(z.string()), - meta_execution_version_ends_with: z.optional(z.string()), - meta_execution_version_like: z.optional(z.string()), - meta_execution_version_not_like: z.optional(z.string()), - meta_execution_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_execution_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_name_eq: z.optional(z.string()), - meta_client_name_ne: z.optional(z.string()), - meta_client_name_contains: z.optional(z.string()), - meta_client_name_starts_with: z.optional(z.string()), - meta_client_name_ends_with: z.optional(z.string()), - meta_client_name_like: z.optional(z.string()), - meta_client_name_not_like: z.optional(z.string()), - meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + effective_bytes_to_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_to_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -102866,18 +105464,12 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListData = z. /** * OK */ -export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceListResponse = - zListIntEngineNewPayloadFastestExecutionByNodeClassResponse; +export const zIntStorageSlotDiffByAddressSlotServiceListResponse = zListIntStorageSlotDiffByAddressSlotResponse; -export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceGetData = z.object({ +export const zIntStorageSlotDiffByAddressSlotServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - slot_start_date_time: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + address: z.string(), }), query: z.optional(z.never()), }); @@ -102885,194 +105477,163 @@ export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceGetData = z.o /** * OK */ -export const zIntEngineNewPayloadFastestExecutionByNodeClassServiceGetResponse = - zGetIntEngineNewPayloadFastestExecutionByNodeClassResponse; +export const zIntStorageSlotDiffByAddressSlotServiceGetResponse = zGetIntStorageSlotDiffByAddressSlotResponse; -export const zIntExecutionBlockByDateServiceListData = z.object({ +export const zIntStorageSlotExpiry1mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - block_date_time_eq: z.optional( - z.coerce - .bigint() + block_number_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_ne: z.optional( - z.coerce - .bigint() + block_number_ne: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_lt: z.optional( - z.coerce - .bigint() + block_number_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_lte: z.optional( - z.coerce - .bigint() + block_number_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_gt: z.optional( - z.coerce - .bigint() + block_number_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_gte: z.optional( - z.coerce - .bigint() + block_number_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_between_min: z.optional( - z.coerce - .bigint() + block_number_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_between_max_value: z.optional( - z.coerce - .bigint() + block_number_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - block_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - block_number_eq: z.optional( - z.coerce - .bigint() + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( - z.coerce - .bigint() + touch_block_ne: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( - z.coerce - .bigint() + touch_block_lt: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( - z.coerce - .bigint() + touch_block_lte: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( - z.coerce - .bigint() + touch_block_gt: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( - z.coerce - .bigint() + touch_block_gte: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( - z.coerce - .bigint() + touch_block_between_min: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( - z.coerce - .bigint() + touch_block_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -103139,6 +105700,72 @@ export const zIntExecutionBlockByDateServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -103156,20 +105783,16 @@ export const zIntExecutionBlockByDateServiceListData = z.object({ /** * OK */ -export const zIntExecutionBlockByDateServiceListResponse = zListIntExecutionBlockByDateResponse; +export const zIntStorageSlotExpiry1mServiceListResponse = zListIntStorageSlotExpiry1mResponse; -export const zIntExecutionBlockByDateServiceGetData = z.object({ +export const zIntStorageSlotExpiry1mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_date_time: z.coerce - .bigint() + block_number: z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ), }), query: z.optional(z.never()), @@ -103178,9 +105801,9 @@ export const zIntExecutionBlockByDateServiceGetData = z.object({ /** * OK */ -export const zIntExecutionBlockByDateServiceGetResponse = zGetIntExecutionBlockByDateResponse; +export const zIntStorageSlotExpiry1mServiceGetResponse = zGetIntStorageSlotExpiry1mResponse; -export const zIntStorageSelfdestructDiffsServiceListData = z.object({ +export const zIntStorageSlotExpiry6mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -103251,16 +105874,25 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_hash_eq: z.optional(z.string()), - transaction_hash_ne: z.optional(z.string()), - transaction_hash_contains: z.optional(z.string()), - transaction_hash_starts_with: z.optional(z.string()), - transaction_hash_ends_with: z.optional(z.string()), - transaction_hash_like: z.optional(z.string()), - transaction_hash_not_like: z.optional(z.string()), - transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - internal_index_eq: z.optional( + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( z .int() .check( @@ -103268,7 +105900,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_ne: z.optional( + touch_block_ne: z.optional( z .int() .check( @@ -103276,7 +105908,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_lt: z.optional( + touch_block_lt: z.optional( z .int() .check( @@ -103284,7 +105916,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_lte: z.optional( + touch_block_lte: z.optional( z .int() .check( @@ -103292,7 +105924,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_gt: z.optional( + touch_block_gt: z.optional( z .int() .check( @@ -103300,7 +105932,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_gte: z.optional( + touch_block_gte: z.optional( z .int() .check( @@ -103308,7 +105940,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_between_min: z.optional( + touch_block_between_min: z.optional( z .int() .check( @@ -103316,7 +105948,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_between_max_value: z.optional( + touch_block_between_max_value: z.optional( z .int() .check( @@ -103324,17 +105956,8 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - internal_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - internal_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_eq: z.optional(z.string()), - slot_ne: z.optional(z.string()), - slot_contains: z.optional(z.string()), - slot_starts_with: z.optional(z.string()), - slot_ends_with: z.optional(z.string()), - slot_like: z.optional(z.string()), - slot_not_like: z.optional(z.string()), - slot_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -103401,7 +106024,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_eq: z.optional( + effective_bytes_eq: z.optional( z .int() .check( @@ -103409,7 +106032,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_ne: z.optional( + effective_bytes_ne: z.optional( z .int() .check( @@ -103417,7 +106040,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_lt: z.optional( + effective_bytes_lt: z.optional( z .int() .check( @@ -103425,7 +106048,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_lte: z.optional( + effective_bytes_lte: z.optional( z .int() .check( @@ -103433,7 +106056,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_gt: z.optional( + effective_bytes_gt: z.optional( z .int() .check( @@ -103441,7 +106064,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_gte: z.optional( + effective_bytes_gte: z.optional( z .int() .check( @@ -103449,7 +106072,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_between_min: z.optional( + effective_bytes_between_min: z.optional( z .int() .check( @@ -103457,7 +106080,7 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z .int() .check( @@ -103465,35 +106088,8 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - from_value_eq: z.optional(z.string()), - from_value_ne: z.optional(z.string()), - from_value_contains: z.optional(z.string()), - from_value_starts_with: z.optional(z.string()), - from_value_ends_with: z.optional(z.string()), - from_value_like: z.optional(z.string()), - from_value_not_like: z.optional(z.string()), - from_value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - from_value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - to_value_eq: z.optional(z.string()), - to_value_ne: z.optional(z.string()), - to_value_contains: z.optional(z.string()), - to_value_starts_with: z.optional(z.string()), - to_value_ends_with: z.optional(z.string()), - to_value_like: z.optional(z.string()), - to_value_not_like: z.optional(z.string()), - to_value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - to_value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -103511,9 +106107,9 @@ export const zIntStorageSelfdestructDiffsServiceListData = z.object({ /** * OK */ -export const zIntStorageSelfdestructDiffsServiceListResponse = zListIntStorageSelfdestructDiffsResponse; +export const zIntStorageSlotExpiry6mServiceListResponse = zListIntStorageSlotExpiry6mResponse; -export const zIntStorageSelfdestructDiffsServiceGetData = z.object({ +export const zIntStorageSlotExpiry6mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -103529,9 +106125,9 @@ export const zIntStorageSelfdestructDiffsServiceGetData = z.object({ /** * OK */ -export const zIntStorageSelfdestructDiffsServiceGetResponse = zGetIntStorageSelfdestructDiffsResponse; +export const zIntStorageSlotExpiry6mServiceGetResponse = zGetIntStorageSlotExpiry6mResponse; -export const zIntStorageSlotDiffServiceListData = z.object({ +export const zIntStorageSlotExpiry12mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -103620,7 +106216,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ slot_key_not_like: z.optional(z.string()), slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( + touch_block_eq: z.optional( z .int() .check( @@ -103628,7 +106224,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + touch_block_ne: z.optional( z .int() .check( @@ -103636,7 +106232,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + touch_block_lt: z.optional( z .int() .check( @@ -103644,7 +106240,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + touch_block_lte: z.optional( z .int() .check( @@ -103652,7 +106248,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + touch_block_gt: z.optional( z .int() .check( @@ -103660,7 +106256,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + touch_block_gte: z.optional( z .int() .check( @@ -103668,7 +106264,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + touch_block_between_min: z.optional( z .int() .check( @@ -103676,7 +106272,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + touch_block_between_max_value: z.optional( z .int() .check( @@ -103684,9 +106280,9 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_from_eq: z.optional( + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -103694,7 +106290,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -103702,7 +106298,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -103710,7 +106306,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -103718,7 +106314,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -103726,7 +106322,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -103734,7 +106330,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -103742,7 +106338,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -103750,9 +106346,9 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_from_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_to_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( z .int() .check( @@ -103760,7 +106356,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_ne: z.optional( + effective_bytes_ne: z.optional( z .int() .check( @@ -103768,7 +106364,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_lt: z.optional( + effective_bytes_lt: z.optional( z .int() .check( @@ -103776,7 +106372,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_lte: z.optional( + effective_bytes_lte: z.optional( z .int() .check( @@ -103784,7 +106380,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_gt: z.optional( + effective_bytes_gt: z.optional( z .int() .check( @@ -103792,7 +106388,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_gte: z.optional( + effective_bytes_gte: z.optional( z .int() .check( @@ -103800,7 +106396,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_between_min: z.optional( + effective_bytes_between_min: z.optional( z .int() .check( @@ -103808,7 +106404,7 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z .int() .check( @@ -103816,8 +106412,8 @@ export const zIntStorageSlotDiffServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_to_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -103835,9 +106431,9 @@ export const zIntStorageSlotDiffServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotDiffServiceListResponse = zListIntStorageSlotDiffResponse; +export const zIntStorageSlotExpiry12mServiceListResponse = zListIntStorageSlotExpiry12mResponse; -export const zIntStorageSlotDiffServiceGetData = z.object({ +export const zIntStorageSlotExpiry12mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -103853,31 +106449,13 @@ export const zIntStorageSlotDiffServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotDiffServiceGetResponse = zGetIntStorageSlotDiffResponse; +export const zIntStorageSlotExpiry12mServiceGetResponse = zGetIntStorageSlotExpiry12mResponse; -export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ +export const zIntStorageSlotExpiry18mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -103944,7 +106522,25 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( z .int() .check( @@ -103952,7 +106548,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + touch_block_ne: z.optional( z .int() .check( @@ -103960,7 +106556,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + touch_block_lt: z.optional( z .int() .check( @@ -103968,7 +106564,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + touch_block_lte: z.optional( z .int() .check( @@ -103976,7 +106572,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + touch_block_gt: z.optional( z .int() .check( @@ -103984,7 +106580,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + touch_block_gte: z.optional( z .int() .check( @@ -103992,7 +106588,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + touch_block_between_min: z.optional( z .int() .check( @@ -104000,7 +106596,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + touch_block_between_max_value: z.optional( z .int() .check( @@ -104008,9 +106604,9 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_from_eq: z.optional( + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -104018,7 +106614,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -104026,7 +106622,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -104034,7 +106630,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -104042,7 +106638,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -104050,7 +106646,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -104058,7 +106654,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -104066,7 +106662,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -104074,9 +106670,9 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_from_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_from_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_to_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_eq: z.optional( z .int() .check( @@ -104084,7 +106680,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_ne: z.optional( + effective_bytes_ne: z.optional( z .int() .check( @@ -104092,7 +106688,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_lt: z.optional( + effective_bytes_lt: z.optional( z .int() .check( @@ -104100,7 +106696,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_lte: z.optional( + effective_bytes_lte: z.optional( z .int() .check( @@ -104108,7 +106704,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_gt: z.optional( + effective_bytes_gt: z.optional( z .int() .check( @@ -104116,7 +106712,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_gte: z.optional( + effective_bytes_gte: z.optional( z .int() .check( @@ -104124,7 +106720,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_between_min: z.optional( + effective_bytes_between_min: z.optional( z .int() .check( @@ -104132,7 +106728,7 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z .int() .check( @@ -104140,8 +106736,8 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - effective_bytes_to_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_to_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -104159,12 +106755,17 @@ export const zIntStorageSlotDiffByAddressSlotServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotDiffByAddressSlotServiceListResponse = zListIntStorageSlotDiffByAddressSlotResponse; +export const zIntStorageSlotExpiry18mServiceListResponse = zListIntStorageSlotExpiry18mResponse; -export const zIntStorageSlotDiffByAddressSlotServiceGetData = z.object({ +export const zIntStorageSlotExpiry18mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - address: z.string(), + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), }), query: z.optional(z.never()), }); @@ -104172,9 +106773,9 @@ export const zIntStorageSlotDiffByAddressSlotServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotDiffByAddressSlotServiceGetResponse = zGetIntStorageSlotDiffByAddressSlotResponse; +export const zIntStorageSlotExpiry18mServiceGetResponse = zGetIntStorageSlotExpiry18mResponse; -export const zIntStorageSlotExpiry1mServiceListData = z.object({ +export const zIntStorageSlotExpiry24mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -104478,9 +107079,9 @@ export const zIntStorageSlotExpiry1mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry1mServiceListResponse = zListIntStorageSlotExpiry1mResponse; +export const zIntStorageSlotExpiry24mServiceListResponse = zListIntStorageSlotExpiry24mResponse; -export const zIntStorageSlotExpiry1mServiceGetData = z.object({ +export const zIntStorageSlotExpiry24mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -104496,9 +107097,267 @@ export const zIntStorageSlotExpiry1mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry1mServiceGetResponse = zGetIntStorageSlotExpiry1mResponse; +export const zIntStorageSlotExpiry24mServiceGetResponse = zGetIntStorageSlotExpiry24mResponse; -export const zIntStorageSlotExpiry6mServiceListData = z.object({ +export const zIntStorageSlotNextTouchServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_eq: z.optional(z.string()), + slot_key_ne: z.optional(z.string()), + slot_key_contains: z.optional(z.string()), + slot_key_starts_with: z.optional(z.string()), + slot_key_ends_with: z.optional(z.string()), + slot_key_like: z.optional(z.string()), + slot_key_not_like: z.optional(z.string()), + slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + next_touch_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + next_touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + next_touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntStorageSlotNextTouchServiceListResponse = zListIntStorageSlotNextTouchResponse; + +export const zIntStorageSlotNextTouchServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + block_number: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntStorageSlotNextTouchServiceGetResponse = zGetIntStorageSlotNextTouchResponse; + +export const zIntStorageSlotReactivation1mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -104802,9 +107661,9 @@ export const zIntStorageSlotExpiry6mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry6mServiceListResponse = zListIntStorageSlotExpiry6mResponse; +export const zIntStorageSlotReactivation1mServiceListResponse = zListIntStorageSlotReactivation1mResponse; -export const zIntStorageSlotExpiry6mServiceGetData = z.object({ +export const zIntStorageSlotReactivation1mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -104820,9 +107679,9 @@ export const zIntStorageSlotExpiry6mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry6mServiceGetResponse = zGetIntStorageSlotExpiry6mResponse; +export const zIntStorageSlotReactivation1mServiceGetResponse = zGetIntStorageSlotReactivation1mResponse; -export const zIntStorageSlotExpiry12mServiceListData = z.object({ +export const zIntStorageSlotReactivation6mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -105126,9 +107985,9 @@ export const zIntStorageSlotExpiry12mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry12mServiceListResponse = zListIntStorageSlotExpiry12mResponse; +export const zIntStorageSlotReactivation6mServiceListResponse = zListIntStorageSlotReactivation6mResponse; -export const zIntStorageSlotExpiry12mServiceGetData = z.object({ +export const zIntStorageSlotReactivation6mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -105144,9 +108003,9 @@ export const zIntStorageSlotExpiry12mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry12mServiceGetResponse = zGetIntStorageSlotExpiry12mResponse; +export const zIntStorageSlotReactivation6mServiceGetResponse = zGetIntStorageSlotReactivation6mResponse; -export const zIntStorageSlotExpiry18mServiceListData = z.object({ +export const zIntStorageSlotReactivation12mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -105450,9 +108309,9 @@ export const zIntStorageSlotExpiry18mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry18mServiceListResponse = zListIntStorageSlotExpiry18mResponse; +export const zIntStorageSlotReactivation12mServiceListResponse = zListIntStorageSlotReactivation12mResponse; -export const zIntStorageSlotExpiry18mServiceGetData = z.object({ +export const zIntStorageSlotReactivation12mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -105468,9 +108327,9 @@ export const zIntStorageSlotExpiry18mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry18mServiceGetResponse = zGetIntStorageSlotExpiry18mResponse; +export const zIntStorageSlotReactivation12mServiceGetResponse = zGetIntStorageSlotReactivation12mResponse; -export const zIntStorageSlotExpiry24mServiceListData = z.object({ +export const zIntStorageSlotReactivation18mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -105774,9 +108633,9 @@ export const zIntStorageSlotExpiry24mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry24mServiceListResponse = zListIntStorageSlotExpiry24mResponse; +export const zIntStorageSlotReactivation18mServiceListResponse = zListIntStorageSlotReactivation18mResponse; -export const zIntStorageSlotExpiry24mServiceGetData = z.object({ +export const zIntStorageSlotReactivation18mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -105792,9 +108651,9 @@ export const zIntStorageSlotExpiry24mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotExpiry24mServiceGetResponse = zGetIntStorageSlotExpiry24mResponse; +export const zIntStorageSlotReactivation18mServiceGetResponse = zGetIntStorageSlotReactivation18mResponse; -export const zIntStorageSlotNextTouchServiceListData = z.object({ +export const zIntStorageSlotReactivation24mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -105883,6 +108742,72 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ slot_key_not_like: z.optional(z.string()), slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + touch_block_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -105949,7 +108874,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - next_touch_block_eq: z.optional( + effective_bytes_eq: z.optional( z .int() .check( @@ -105957,7 +108882,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_ne: z.optional( + effective_bytes_ne: z.optional( z .int() .check( @@ -105965,7 +108890,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_lt: z.optional( + effective_bytes_lt: z.optional( z .int() .check( @@ -105973,7 +108898,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_lte: z.optional( + effective_bytes_lte: z.optional( z .int() .check( @@ -105981,7 +108906,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_gt: z.optional( + effective_bytes_gt: z.optional( z .int() .check( @@ -105989,7 +108914,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_gte: z.optional( + effective_bytes_gte: z.optional( z .int() .check( @@ -105997,7 +108922,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_between_min: z.optional( + effective_bytes_between_min: z.optional( z .int() .check( @@ -106005,7 +108930,7 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_between_max_value: z.optional( + effective_bytes_between_max_value: z.optional( z .int() .check( @@ -106013,8 +108938,8 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - next_touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - next_touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -106032,9 +108957,9 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotNextTouchServiceListResponse = zListIntStorageSlotNextTouchResponse; +export const zIntStorageSlotReactivation24mServiceListResponse = zListIntStorageSlotReactivation24mResponse; -export const zIntStorageSlotNextTouchServiceGetData = z.object({ +export const zIntStorageSlotReactivation24mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -106050,9 +108975,9 @@ export const zIntStorageSlotNextTouchServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotNextTouchServiceGetResponse = zGetIntStorageSlotNextTouchResponse; +export const zIntStorageSlotReactivation24mServiceGetResponse = zGetIntStorageSlotReactivation24mResponse; -export const zIntStorageSlotReactivation1mServiceListData = z.object({ +export const zIntStorageSlotReadServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -106141,72 +109066,6 @@ export const zIntStorageSlotReactivation1mServiceListData = z.object({ slot_key_not_like: z.optional(z.string()), slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -106273,72 +109132,6 @@ export const zIntStorageSlotReactivation1mServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -106356,9 +109149,9 @@ export const zIntStorageSlotReactivation1mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation1mServiceListResponse = zListIntStorageSlotReactivation1mResponse; +export const zIntStorageSlotReadServiceListResponse = zListIntStorageSlotReadResponse; -export const zIntStorageSlotReactivation1mServiceGetData = z.object({ +export const zIntStorageSlotReadServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -106374,9 +109167,9 @@ export const zIntStorageSlotReactivation1mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation1mServiceGetResponse = zGetIntStorageSlotReactivation1mResponse; +export const zIntStorageSlotReadServiceGetResponse = zGetIntStorageSlotReadResponse; -export const zIntStorageSlotReactivation6mServiceListData = z.object({ +export const zIntStorageSlotStateServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -106456,16 +109249,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ address_not_like: z.optional(z.string()), address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( + updated_date_time_eq: z.optional( z .int() .check( @@ -106473,7 +109257,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -106481,7 +109265,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -106489,7 +109273,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -106497,7 +109281,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -106505,7 +109289,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -106513,7 +109297,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -106521,7 +109305,7 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -106529,140 +109313,368 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_eq: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_gte: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_min: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_between_max_value: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gte: z.optional( - z - .int() + active_slots_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_min: z.optional( - z - .int() + active_slots_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + active_slots_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), effective_bytes_eq: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_ne: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_min: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_max_value: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -106680,9 +109692,9 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation6mServiceListResponse = zListIntStorageSlotReactivation6mResponse; +export const zIntStorageSlotStateServiceListResponse = zListIntStorageSlotStateResponse; -export const zIntStorageSlotReactivation6mServiceGetData = z.object({ +export const zIntStorageSlotStateServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -106698,13 +109710,22 @@ export const zIntStorageSlotReactivation6mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation6mServiceGetResponse = zGetIntStorageSlotReactivation6mResponse; +export const zIntStorageSlotStateServiceGetResponse = zGetIntStorageSlotStateResponse; -export const zIntStorageSlotReactivation12mServiceListData = z.object({ +export const zIntStorageSlotStateByAddressServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + address_eq: z.optional(z.string()), + address_ne: z.optional(z.string()), + address_contains: z.optional(z.string()), + address_starts_with: z.optional(z.string()), + address_ends_with: z.optional(z.string()), + address_like: z.optional(z.string()), + address_not_like: z.optional(z.string()), + address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -106771,25 +109792,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( + updated_date_time_eq: z.optional( z .int() .check( @@ -106797,7 +109800,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -106805,7 +109808,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -106813,7 +109816,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -106821,7 +109824,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -106829,7 +109832,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -106837,7 +109840,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -106845,7 +109848,7 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -106853,140 +109856,368 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_eq: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_gte: z.optional( + slots_delta_gte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_between_min: z.optional( + slots_delta_between_min: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_between_max_value: z.optional( + slots_delta_between_max_value: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), effective_bytes_eq: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_ne: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_min: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_max_value: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -107004,17 +110235,12 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation12mServiceListResponse = zListIntStorageSlotReactivation12mResponse; +export const zIntStorageSlotStateByAddressServiceListResponse = zListIntStorageSlotStateByAddressResponse; -export const zIntStorageSlotReactivation12mServiceGetData = z.object({ +export const zIntStorageSlotStateByAddressServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + address: z.string(), }), query: z.optional(z.never()), }); @@ -107022,9 +110248,9 @@ export const zIntStorageSlotReactivation12mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation12mServiceGetResponse = zGetIntStorageSlotReactivation12mResponse; +export const zIntStorageSlotStateByAddressServiceGetResponse = zGetIntStorageSlotStateByAddressResponse; -export const zIntStorageSlotReactivation18mServiceListData = z.object({ +export const zIntStorageSlotStateByBlockServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -107095,90 +110321,6 @@ export const zIntStorageSlotReactivation18mServiceListData = z.object({ ), block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -107245,73 +110387,7 @@ export const zIntStorageSlotReactivation18mServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: z.optional( + slots_delta_eq: z.optional( z .int() .check( @@ -107319,322 +110395,358 @@ export const zIntStorageSlotReactivation18mServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntStorageSlotReactivation18mServiceListResponse = zListIntStorageSlotReactivation18mResponse; - -export const zIntStorageSlotReactivation18mServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntStorageSlotReactivation18mServiceGetResponse = zGetIntStorageSlotReactivation18mResponse; - -export const zIntStorageSlotReactivation24mServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - block_number_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_ne: z.optional( + slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_lt: z.optional( + slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_lte: z.optional( + slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_gt: z.optional( + slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_gte: z.optional( + slots_delta_gte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_between_min: z.optional( + slots_delta_between_min: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_between_max_value: z.optional( + slots_delta_between_max_value: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - touch_block_eq: z.optional( - z - .int() + slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_ne: z.optional( - z - .int() + bytes_delta_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_lt: z.optional( - z - .int() + bytes_delta_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_lte: z.optional( - z - .int() + bytes_delta_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_gt: z.optional( - z - .int() + bytes_delta_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_gte: z.optional( - z - .int() + bytes_delta_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_between_min: z.optional( - z - .int() + bytes_delta_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_between_max_value: z.optional( - z - .int() + bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - touch_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - touch_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( - z - .int() + bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_ne: z.optional( - z - .int() + active_slots_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_lt: z.optional( - z - .int() + active_slots_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_lte: z.optional( - z - .int() + active_slots_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gt: z.optional( - z - .int() + active_slots_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gte: z.optional( - z - .int() + active_slots_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_min: z.optional( - z - .int() + active_slots_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + active_slots_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), effective_bytes_eq: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_ne: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_lte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gt: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_gte: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_min: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), effective_bytes_between_max_value: z.optional( - z - .int() + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), page_size: z.optional( z .int() @@ -107652,9 +110764,9 @@ export const zIntStorageSlotReactivation24mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation24mServiceListResponse = zListIntStorageSlotReactivation24mResponse; +export const zIntStorageSlotStateByBlockServiceListResponse = zListIntStorageSlotStateByBlockResponse; -export const zIntStorageSlotReactivation24mServiceGetData = z.object({ +export const zIntStorageSlotStateByBlockServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -107670,13 +110782,22 @@ export const zIntStorageSlotReactivation24mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation24mServiceGetResponse = zGetIntStorageSlotReactivation24mResponse; +export const zIntStorageSlotStateByBlockServiceGetResponse = zGetIntStorageSlotStateByBlockResponse; -export const zIntStorageSlotReadServiceListData = z.object({ +export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + expiry_policy_eq: z.optional(z.string()), + expiry_policy_ne: z.optional(z.string()), + expiry_policy_contains: z.optional(z.string()), + expiry_policy_starts_with: z.optional(z.string()), + expiry_policy_ends_with: z.optional(z.string()), + expiry_policy_like: z.optional(z.string()), + expiry_policy_not_like: z.optional(z.string()), + expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -107752,15 +110873,6 @@ export const zIntStorageSlotReadServiceListData = z.object({ address_not_like: z.optional(z.string()), address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_eq: z.optional(z.string()), - slot_key_ne: z.optional(z.string()), - slot_key_contains: z.optional(z.string()), - slot_key_starts_with: z.optional(z.string()), - slot_key_ends_with: z.optional(z.string()), - slot_key_like: z.optional(z.string()), - slot_key_not_like: z.optional(z.string()), - slot_key_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - slot_key_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -107827,7 +110939,7 @@ export const zIntStorageSlotReadServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: z.optional( + net_slots_delta_eq: z.optional( z .int() .check( @@ -107835,248 +110947,261 @@ export const zIntStorageSlotReadServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntStorageSlotReadServiceListResponse = zListIntStorageSlotReadResponse; - -export const zIntStorageSlotReadServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntStorageSlotReadServiceGetResponse = zGetIntStorageSlotReadResponse; - -export const zIntStorageSlotStateServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - block_number_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_ne: z.optional( + net_slots_delta_ne: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_lt: z.optional( + net_slots_delta_lt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_lte: z.optional( + net_slots_delta_lte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_gt: z.optional( + net_slots_delta_gt: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_gte: z.optional( + net_slots_delta_gte: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_between_min: z.optional( + net_slots_delta_between_min: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_between_max_value: z.optional( + net_slots_delta_between_max_value: z.optional( z .int() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( - z - .int() + net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_ne: z.optional( - z - .int() + net_bytes_delta_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_lt: z.optional( - z - .int() + net_bytes_delta_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_lte: z.optional( - z - .int() + net_bytes_delta_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gt: z.optional( - z - .int() + net_bytes_delta_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_gte: z.optional( - z - .int() + net_bytes_delta_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_min: z.optional( - z - .int() + net_bytes_delta_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + net_bytes_delta_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( - z - .int() + net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_ne: z.optional( - z - .int() + cumulative_net_slots_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_lt: z.optional( - z - .int() + cumulative_net_slots_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_lte: z.optional( - z - .int() + cumulative_net_slots_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_gt: z.optional( - z - .int() + cumulative_net_slots_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_gte: z.optional( - z - .int() + cumulative_net_slots_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_between_min: z.optional( - z - .int() + cumulative_net_slots_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_between_max_value: z.optional( - z - .int() + cumulative_net_slots_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) ) ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( + cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -108088,7 +111213,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + cumulative_net_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -108100,7 +111225,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + cumulative_net_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -108112,7 +111237,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + cumulative_net_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -108124,7 +111249,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + cumulative_net_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -108136,7 +111261,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + cumulative_net_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -108148,7 +111273,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + cumulative_net_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -108160,7 +111285,7 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_between_max_value: z.optional( + cumulative_net_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -108172,8 +111297,8 @@ export const zIntStorageSlotStateServiceListData = z.object({ }) ) ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() @@ -108387,17 +111512,12 @@ export const zIntStorageSlotStateServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateServiceListResponse = zListIntStorageSlotStateResponse; +export const zIntStorageSlotStateWithExpiryServiceListResponse = zListIntStorageSlotStateWithExpiryResponse; -export const zIntStorageSlotStateServiceGetData = z.object({ +export const zIntStorageSlotStateWithExpiryServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + expiry_policy: z.string(), }), query: z.optional(z.never()), }); @@ -108405,9 +111525,9 @@ export const zIntStorageSlotStateServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateServiceGetResponse = zGetIntStorageSlotStateResponse; +export const zIntStorageSlotStateWithExpiryServiceGetResponse = zGetIntStorageSlotStateWithExpiryResponse; -export const zIntStorageSlotStateByAddressServiceListData = z.object({ +export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -108421,6 +111541,15 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ address_not_like: z.optional(z.string()), address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_eq: z.optional(z.string()), + expiry_policy_ne: z.optional(z.string()), + expiry_policy_contains: z.optional(z.string()), + expiry_policy_starts_with: z.optional(z.string()), + expiry_policy_ends_with: z.optional(z.string()), + expiry_policy_like: z.optional(z.string()), + expiry_policy_not_like: z.optional(z.string()), + expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -108553,7 +111682,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( + net_slots_delta_eq: z.optional( z .int() .check( @@ -108561,7 +111690,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_ne: z.optional( + net_slots_delta_ne: z.optional( z .int() .check( @@ -108569,7 +111698,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lt: z.optional( + net_slots_delta_lt: z.optional( z .int() .check( @@ -108577,7 +111706,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lte: z.optional( + net_slots_delta_lte: z.optional( z .int() .check( @@ -108585,7 +111714,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gt: z.optional( + net_slots_delta_gt: z.optional( z .int() .check( @@ -108593,7 +111722,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gte: z.optional( + net_slots_delta_gte: z.optional( z .int() .check( @@ -108601,7 +111730,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_min: z.optional( + net_slots_delta_between_min: z.optional( z .int() .check( @@ -108609,7 +111738,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_max_value: z.optional( + net_slots_delta_between_max_value: z.optional( z .int() .check( @@ -108617,9 +111746,9 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( + net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_eq: z.optional( z.coerce .bigint() .check( @@ -108631,7 +111760,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + net_bytes_delta_ne: z.optional( z.coerce .bigint() .check( @@ -108643,7 +111772,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + net_bytes_delta_lt: z.optional( z.coerce .bigint() .check( @@ -108655,7 +111784,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + net_bytes_delta_lte: z.optional( z.coerce .bigint() .check( @@ -108667,7 +111796,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + net_bytes_delta_gt: z.optional( z.coerce .bigint() .check( @@ -108679,7 +111808,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + net_bytes_delta_gte: z.optional( z.coerce .bigint() .check( @@ -108691,7 +111820,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + net_bytes_delta_between_min: z.optional( z.coerce .bigint() .check( @@ -108703,7 +111832,7 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_between_max_value: z.optional( + net_bytes_delta_between_max_value: z.optional( z.coerce .bigint() .check( @@ -108715,8 +111844,204 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ }) ) ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() @@ -108930,9 +112255,10 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateByAddressServiceListResponse = zListIntStorageSlotStateByAddressResponse; +export const zIntStorageSlotStateWithExpiryByAddressServiceListResponse = + zListIntStorageSlotStateWithExpiryByAddressResponse; -export const zIntStorageSlotStateByAddressServiceGetData = z.object({ +export const zIntStorageSlotStateWithExpiryByAddressServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ address: z.string(), @@ -108943,13 +112269,23 @@ export const zIntStorageSlotStateByAddressServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateByAddressServiceGetResponse = zGetIntStorageSlotStateByAddressResponse; +export const zIntStorageSlotStateWithExpiryByAddressServiceGetResponse = + zGetIntStorageSlotStateWithExpiryByAddressResponse; -export const zIntStorageSlotStateByBlockServiceListData = z.object({ +export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ + expiry_policy_eq: z.optional(z.string()), + expiry_policy_ne: z.optional(z.string()), + expiry_policy_contains: z.optional(z.string()), + expiry_policy_starts_with: z.optional(z.string()), + expiry_policy_ends_with: z.optional(z.string()), + expiry_policy_like: z.optional(z.string()), + expiry_policy_not_like: z.optional(z.string()), + expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( z .int() @@ -109082,7 +112418,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slots_delta_eq: z.optional( + net_slots_delta_eq: z.optional( z .int() .check( @@ -109090,7 +112426,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_ne: z.optional( + net_slots_delta_ne: z.optional( z .int() .check( @@ -109098,7 +112434,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lt: z.optional( + net_slots_delta_lt: z.optional( z .int() .check( @@ -109106,7 +112442,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_lte: z.optional( + net_slots_delta_lte: z.optional( z .int() .check( @@ -109114,7 +112450,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gt: z.optional( + net_slots_delta_gt: z.optional( z .int() .check( @@ -109122,7 +112458,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_gte: z.optional( + net_slots_delta_gte: z.optional( z .int() .check( @@ -109130,7 +112466,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_min: z.optional( + net_slots_delta_between_min: z.optional( z .int() .check( @@ -109138,7 +112474,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_between_max_value: z.optional( + net_slots_delta_between_max_value: z.optional( z .int() .check( @@ -109146,9 +112482,9 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_eq: z.optional( + net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_eq: z.optional( z.coerce .bigint() .check( @@ -109160,7 +112496,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + net_bytes_delta_ne: z.optional( z.coerce .bigint() .check( @@ -109172,7 +112508,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + net_bytes_delta_lt: z.optional( z.coerce .bigint() .check( @@ -109184,7 +112520,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + net_bytes_delta_lte: z.optional( z.coerce .bigint() .check( @@ -109196,7 +112532,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + net_bytes_delta_gt: z.optional( z.coerce .bigint() .check( @@ -109208,7 +112544,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + net_bytes_delta_gte: z.optional( z.coerce .bigint() .check( @@ -109220,7 +112556,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + net_bytes_delta_between_min: z.optional( z.coerce .bigint() .check( @@ -109232,7 +112568,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_between_max_value: z.optional( + net_bytes_delta_between_max_value: z.optional( z.coerce .bigint() .check( @@ -109244,8 +112580,204 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808', + }), + z.maximum(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + }) + ) + ), + cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), active_slots_eq: z.optional( z.coerce .bigint() @@ -109459,17 +112991,13 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateByBlockServiceListResponse = zListIntStorageSlotStateByBlockResponse; +export const zIntStorageSlotStateWithExpiryByBlockServiceListResponse = + zListIntStorageSlotStateWithExpiryByBlockResponse; -export const zIntStorageSlotStateByBlockServiceGetData = z.object({ +export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - block_number: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + expiry_policy: z.string(), }), query: z.optional(z.never()), }); @@ -109477,23 +113005,245 @@ export const zIntStorageSlotStateByBlockServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateByBlockServiceGetResponse = zGetIntStorageSlotStateByBlockResponse; +export const zIntStorageSlotStateWithExpiryByBlockServiceGetResponse = zGetIntStorageSlotStateWithExpiryByBlockResponse; -export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ +export const zIntTransactionCallFrameServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - expiry_policy_eq: z.optional(z.string()), - expiry_policy_ne: z.optional(z.string()), - expiry_policy_contains: z.optional(z.string()), - expiry_policy_starts_with: z.optional(z.string()), - expiry_policy_ends_with: z.optional(z.string()), - expiry_policy_like: z.optional(z.string()), - expiry_policy_not_like: z.optional(z.string()), - expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_hash_eq: z.optional(z.string()), + transaction_hash_ne: z.optional(z.string()), + transaction_hash_contains: z.optional(z.string()), + transaction_hash_starts_with: z.optional(z.string()), + transaction_hash_ends_with: z.optional(z.string()), + transaction_hash_like: z.optional(z.string()), + transaction_hash_not_like: z.optional(z.string()), + transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + call_frame_id_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + transaction_index_ne: z.optional( z .int() .check( @@ -109501,7 +113251,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + transaction_index_lt: z.optional( z .int() .check( @@ -109509,7 +113259,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + transaction_index_lte: z.optional( z .int() .check( @@ -109517,7 +113267,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + transaction_index_gt: z.optional( z .int() .check( @@ -109525,7 +113275,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + transaction_index_gte: z.optional( z .int() .check( @@ -109533,7 +113283,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + transaction_index_between_min: z.optional( z .int() .check( @@ -109541,7 +113291,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + transaction_index_between_max_value: z.optional( z .int() .check( @@ -109549,7 +113299,9 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + parent_call_frame_id_eq: z.optional( z .int() .check( @@ -109557,18 +113309,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( + parent_call_frame_id_ne: z.optional( z .int() .check( @@ -109576,7 +113317,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + parent_call_frame_id_lt: z.optional( z .int() .check( @@ -109584,7 +113325,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + parent_call_frame_id_lte: z.optional( z .int() .check( @@ -109592,7 +113333,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + parent_call_frame_id_gt: z.optional( z .int() .check( @@ -109600,7 +113341,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + parent_call_frame_id_gte: z.optional( z .int() .check( @@ -109608,7 +113349,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + parent_call_frame_id_between_min: z.optional( z .int() .check( @@ -109616,7 +113357,7 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + parent_call_frame_id_between_max_value: z.optional( z .int() .check( @@ -109624,7 +113365,9 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + parent_call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + parent_call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + depth_eq: z.optional( z .int() .check( @@ -109632,564 +113375,665 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - net_slots_delta_eq: z.optional( + depth_ne: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_ne: z.optional( + depth_lt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_lt: z.optional( + depth_lte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_lte: z.optional( + depth_gt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_gt: z.optional( + depth_gte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_gte: z.optional( + depth_between_min: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_between_min: z.optional( + depth_between_max_value: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_between_max_value: z.optional( - z - .int() + depth_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + depth_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + target_address_eq: z.optional(z.string()), + target_address_ne: z.optional(z.string()), + target_address_contains: z.optional(z.string()), + target_address_starts_with: z.optional(z.string()), + target_address_ends_with: z.optional(z.string()), + target_address_like: z.optional(z.string()), + target_address_not_like: z.optional(z.string()), + target_address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + target_address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + call_type_eq: z.optional(z.string()), + call_type_ne: z.optional(z.string()), + call_type_contains: z.optional(z.string()), + call_type_starts_with: z.optional(z.string()), + call_type_ends_with: z.optional(z.string()), + call_type_like: z.optional(z.string()), + call_type_not_like: z.optional(z.string()), + call_type_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + call_type_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + function_selector_eq: z.optional(z.string()), + function_selector_ne: z.optional(z.string()), + function_selector_contains: z.optional(z.string()), + function_selector_starts_with: z.optional(z.string()), + function_selector_ends_with: z.optional(z.string()), + function_selector_like: z.optional(z.string()), + function_selector_not_like: z.optional(z.string()), + function_selector_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + function_selector_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + opcode_count_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_eq: z.optional( + opcode_count_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_ne: z.optional( + opcode_count_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_lt: z.optional( + opcode_count_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_lte: z.optional( + opcode_count_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_gt: z.optional( + opcode_count_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_gte: z.optional( + opcode_count_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_between_min: z.optional( + opcode_count_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_between_max_value: z.optional( + opcode_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + opcode_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + error_count_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_eq: z.optional( + error_count_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_ne: z.optional( + error_count_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_lt: z.optional( + error_count_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_lte: z.optional( + error_count_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gt: z.optional( + error_count_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gte: z.optional( + error_count_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_min: z.optional( + error_count_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_max_value: z.optional( + error_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + error_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_eq: z.optional( + gas_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_ne: z.optional( + gas_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lt: z.optional( + gas_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lte: z.optional( + gas_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gt: z.optional( + gas_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gte: z.optional( + gas_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_cumulative_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_cumulative_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_cumulative_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_min: z.optional( + gas_refund_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_max_value: z.optional( + gas_refund_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + gas_refund_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + intrinsic_gas_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_ne: z.optional( + intrinsic_gas_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lt: z.optional( + intrinsic_gas_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lte: z.optional( + intrinsic_gas_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gt: z.optional( + intrinsic_gas_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gte: z.optional( + intrinsic_gas_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_min: z.optional( + intrinsic_gas_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_max_value: z.optional( + intrinsic_gas_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( + intrinsic_gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + intrinsic_gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + receipt_gas_used_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_ne: z.optional( + receipt_gas_used_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lt: z.optional( + receipt_gas_used_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lte: z.optional( + receipt_gas_used_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gt: z.optional( + receipt_gas_used_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gte: z.optional( + receipt_gas_used_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_min: z.optional( + receipt_gas_used_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_max_value: z.optional( + receipt_gas_used_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + receipt_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + receipt_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -110207,12 +114051,19 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryServiceListResponse = zListIntStorageSlotStateWithExpiryResponse; +export const zIntTransactionCallFrameServiceListResponse = zListIntTransactionCallFrameResponse; -export const zIntStorageSlotStateWithExpiryServiceGetData = z.object({ +export const zIntTransactionCallFrameServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - expiry_policy: z.string(), + block_number: z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ), }), query: z.optional(z.never()), }); @@ -110220,32 +114071,105 @@ export const zIntStorageSlotStateWithExpiryServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryServiceGetResponse = zGetIntStorageSlotStateWithExpiryResponse; +export const zIntTransactionCallFrameServiceGetResponse = zGetIntTransactionCallFrameResponse; -export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ +export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - address_eq: z.optional(z.string()), - address_ne: z.optional(z.string()), - address_contains: z.optional(z.string()), - address_starts_with: z.optional(z.string()), - address_ends_with: z.optional(z.string()), - address_like: z.optional(z.string()), - address_not_like: z.optional(z.string()), - address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_eq: z.optional(z.string()), - expiry_policy_ne: z.optional(z.string()), - expiry_policy_contains: z.optional(z.string()), - expiry_policy_starts_with: z.optional(z.string()), - expiry_policy_ends_with: z.optional(z.string()), - expiry_policy_like: z.optional(z.string()), - expiry_policy_not_like: z.optional(z.string()), - expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), block_number_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_hash_eq: z.optional(z.string()), + transaction_hash_ne: z.optional(z.string()), + transaction_hash_contains: z.optional(z.string()), + transaction_hash_starts_with: z.optional(z.string()), + transaction_hash_ends_with: z.optional(z.string()), + transaction_hash_like: z.optional(z.string()), + transaction_hash_not_like: z.optional(z.string()), + transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + call_frame_id_eq: z.optional( z .int() .check( @@ -110253,7 +114177,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + call_frame_id_ne: z.optional( z .int() .check( @@ -110261,7 +114185,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + call_frame_id_lt: z.optional( z .int() .check( @@ -110269,7 +114193,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + call_frame_id_lte: z.optional( z .int() .check( @@ -110277,7 +114201,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + call_frame_id_gt: z.optional( z .int() .check( @@ -110285,7 +114209,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + call_frame_id_gte: z.optional( z .int() .check( @@ -110293,7 +114217,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + call_frame_id_between_min: z.optional( z .int() .check( @@ -110301,7 +114225,7 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + call_frame_id_between_max_value: z.optional( z .int() .check( @@ -110309,8 +114233,26 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + opcode_eq: z.optional(z.string()), + opcode_ne: z.optional(z.string()), + opcode_contains: z.optional(z.string()), + opcode_starts_with: z.optional(z.string()), + opcode_ends_with: z.optional(z.string()), + opcode_like: z.optional(z.string()), + opcode_not_like: z.optional(z.string()), + opcode_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + opcode_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_eq: z.optional(z.string()), + meta_network_name_ne: z.optional(z.string()), + meta_network_name_contains: z.optional(z.string()), + meta_network_name_starts_with: z.optional(z.string()), + meta_network_name_ends_with: z.optional(z.string()), + meta_network_name_like: z.optional(z.string()), + meta_network_name_not_like: z.optional(z.string()), + meta_network_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -110377,1298 +114319,892 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ ), updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - net_slots_delta_eq: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_ne: z.optional( + transaction_index_eq: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_lt: z.optional( + transaction_index_ne: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_lte: z.optional( + transaction_index_lt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_gt: z.optional( + transaction_index_lte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_gte: z.optional( + transaction_index_gt: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_between_min: z.optional( + transaction_index_gte: z.optional( z .int() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - net_slots_delta_between_max_value: z.optional( + transaction_index_between_min: z.optional( z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_eq: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_ne: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_lt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_lte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_gt: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_gte: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_between_min: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_between_max_value: z.optional( - z.coerce - .bigint() - .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) - ) - ), - net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_eq: z.optional( - z.coerce - .bigint() + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - cumulative_net_slots_ne: z.optional( - z.coerce - .bigint() + transaction_index_between_max_value: z.optional( + z + .int() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', - }) + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - cumulative_net_slots_lt: z.optional( + transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + count_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_lte: z.optional( + count_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gt: z.optional( + count_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gte: z.optional( + count_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_min: z.optional( + count_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_max_value: z.optional( + count_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_eq: z.optional( + count_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_ne: z.optional( + count_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lt: z.optional( + count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lte: z.optional( + gas_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gt: z.optional( + gas_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gte: z.optional( + gas_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_min: z.optional( + gas_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_max_value: z.optional( + gas_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + gas_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_ne: z.optional( + gas_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lt: z.optional( + gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_cumulative_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lte: z.optional( + gas_cumulative_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gt: z.optional( + gas_cumulative_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gte: z.optional( + gas_cumulative_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_min: z.optional( + gas_cumulative_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_max_value: z.optional( + gas_cumulative_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( + gas_cumulative_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_ne: z.optional( + gas_cumulative_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lt: z.optional( + gas_cumulative_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_cumulative_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + error_count_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lte: z.optional( + error_count_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gt: z.optional( + error_count_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gte: z.optional( + error_count_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_min: z.optional( + error_count_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_max_value: z.optional( + error_count_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - page_size: z.optional( - z - .int() - .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) - ) - ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntStorageSlotStateWithExpiryByAddressServiceListResponse = - zListIntStorageSlotStateWithExpiryByAddressResponse; - -export const zIntStorageSlotStateWithExpiryByAddressServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - address: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntStorageSlotStateWithExpiryByAddressServiceGetResponse = - zGetIntStorageSlotStateWithExpiryByAddressResponse; - -export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - expiry_policy_eq: z.optional(z.string()), - expiry_policy_ne: z.optional(z.string()), - expiry_policy_contains: z.optional(z.string()), - expiry_policy_starts_with: z.optional(z.string()), - expiry_policy_ends_with: z.optional(z.string()), - expiry_policy_like: z.optional(z.string()), - expiry_policy_not_like: z.optional(z.string()), - expiry_policy_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - expiry_policy_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - block_number_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - updated_date_time_between_min: z.optional( - z - .int() + error_count_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + error_count_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - net_slots_delta_eq: z.optional( - z - .int() + error_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + error_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sum_before_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_ne: z.optional( - z - .int() + memory_words_sum_before_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_lt: z.optional( - z - .int() + memory_words_sum_before_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_lte: z.optional( - z - .int() + memory_words_sum_before_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_gt: z.optional( - z - .int() + memory_words_sum_before_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_gte: z.optional( - z - .int() + memory_words_sum_before_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_between_min: z.optional( - z - .int() + memory_words_sum_before_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_between_max_value: z.optional( - z - .int() + memory_words_sum_before_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), - z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - net_slots_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_slots_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_eq: z.optional( + memory_words_sum_before_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sum_before_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sum_after_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_ne: z.optional( + memory_words_sum_after_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_lt: z.optional( + memory_words_sum_after_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_lte: z.optional( + memory_words_sum_after_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_gt: z.optional( + memory_words_sum_after_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_gte: z.optional( + memory_words_sum_after_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_between_min: z.optional( + memory_words_sum_after_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_between_max_value: z.optional( + memory_words_sum_after_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - net_bytes_delta_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - net_bytes_delta_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_eq: z.optional( + memory_words_sum_after_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sum_after_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sq_sum_before_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_ne: z.optional( + memory_words_sq_sum_before_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_lt: z.optional( + memory_words_sq_sum_before_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_lte: z.optional( + memory_words_sq_sum_before_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gt: z.optional( + memory_words_sq_sum_before_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_gte: z.optional( + memory_words_sq_sum_before_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_min: z.optional( + memory_words_sq_sum_before_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_between_max_value: z.optional( + memory_words_sq_sum_before_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_eq: z.optional( + memory_words_sq_sum_before_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sq_sum_before_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sq_sum_after_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_ne: z.optional( + memory_words_sq_sum_after_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lt: z.optional( + memory_words_sq_sum_after_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_lte: z.optional( + memory_words_sq_sum_after_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gt: z.optional( + memory_words_sq_sum_after_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_gte: z.optional( + memory_words_sq_sum_after_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_min: z.optional( + memory_words_sq_sum_after_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_between_max_value: z.optional( + memory_words_sq_sum_after_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - cumulative_net_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - cumulative_net_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_eq: z.optional( + memory_words_sq_sum_after_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_words_sq_sum_after_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_expansion_gas_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_ne: z.optional( + memory_expansion_gas_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lt: z.optional( + memory_expansion_gas_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_lte: z.optional( + memory_expansion_gas_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gt: z.optional( + memory_expansion_gas_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_gte: z.optional( + memory_expansion_gas_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_min: z.optional( + memory_expansion_gas_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_between_max_value: z.optional( + memory_expansion_gas_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - active_slots_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - active_slots_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_eq: z.optional( + memory_expansion_gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + memory_expansion_gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cold_access_count_eq: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_ne: z.optional( + cold_access_count_ne: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lt: z.optional( + cold_access_count_lt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_lte: z.optional( + cold_access_count_lte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gt: z.optional( + cold_access_count_gt: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_gte: z.optional( + cold_access_count_gte: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_min: z.optional( + cold_access_count_between_min: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_between_max_value: z.optional( + cold_access_count_between_max_value: z.optional( z.coerce .bigint() .check( - z.minimum(BigInt('-9223372036854775808'), { - error: 'Invalid value: Expected int64 to be >= -9223372036854775808', - }), - z.maximum(BigInt('9223372036854775807'), { - error: 'Invalid value: Expected int64 to be <= 9223372036854775807', + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', }) ) ), - effective_bytes_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - effective_bytes_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + cold_access_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cold_access_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -111686,13 +115222,19 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByBlockServiceListResponse = - zListIntStorageSlotStateWithExpiryByBlockResponse; +export const zIntTransactionCallFrameOpcodeGasServiceListResponse = zListIntTransactionCallFrameOpcodeGasResponse; -export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = z.object({ +export const zIntTransactionCallFrameOpcodeGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - expiry_policy: z.string(), + block_number: z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ), }), query: z.optional(z.never()), }); @@ -111700,9 +115242,9 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByBlockServiceGetResponse = zGetIntStorageSlotStateWithExpiryByBlockResponse; +export const zIntTransactionCallFrameOpcodeGasServiceGetResponse = zGetIntTransactionCallFrameOpcodeGasResponse; -export const zIntTransactionCallFrameServiceListData = z.object({ +export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -111864,6 +115406,24 @@ export const zIntTransactionCallFrameServiceListData = z.object({ ), call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + opcode_eq: z.optional(z.string()), + opcode_ne: z.optional(z.string()), + opcode_contains: z.optional(z.string()), + opcode_starts_with: z.optional(z.string()), + opcode_ends_with: z.optional(z.string()), + opcode_like: z.optional(z.string()), + opcode_not_like: z.optional(z.string()), + opcode_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + opcode_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_eq: z.optional(z.string()), + meta_network_name_ne: z.optional(z.string()), + meta_network_name_contains: z.optional(z.string()), + meta_network_name_starts_with: z.optional(z.string()), + meta_network_name_ends_with: z.optional(z.string()), + meta_network_name_like: z.optional(z.string()), + meta_network_name_not_like: z.optional(z.string()), + meta_network_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_network_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -111996,166 +115556,171 @@ export const zIntTransactionCallFrameServiceListData = z.object({ ), transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - parent_call_frame_id_eq: z.optional( - z - .int() + count_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_ne: z.optional( - z - .int() + count_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_lt: z.optional( - z - .int() + count_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_lte: z.optional( - z - .int() + count_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_gt: z.optional( - z - .int() + count_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_gte: z.optional( - z - .int() + count_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_between_min: z.optional( - z - .int() + count_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_between_max_value: z.optional( - z - .int() + count_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - parent_call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - parent_call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - depth_eq: z.optional( - z - .int() + count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_eq: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_ne: z.optional( - z - .int() + gas_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_lt: z.optional( - z - .int() + gas_lt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_lte: z.optional( - z - .int() + gas_lte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_gt: z.optional( - z - .int() + gas_gt: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_gte: z.optional( - z - .int() + gas_gte: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_between_min: z.optional( - z - .int() + gas_between_min: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_between_max_value: z.optional( - z - .int() + gas_between_max_value: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) ) ), - depth_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - depth_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - target_address_eq: z.optional(z.string()), - target_address_ne: z.optional(z.string()), - target_address_contains: z.optional(z.string()), - target_address_starts_with: z.optional(z.string()), - target_address_ends_with: z.optional(z.string()), - target_address_like: z.optional(z.string()), - target_address_not_like: z.optional(z.string()), - target_address_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - target_address_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - call_type_eq: z.optional(z.string()), - call_type_ne: z.optional(z.string()), - call_type_contains: z.optional(z.string()), - call_type_starts_with: z.optional(z.string()), - call_type_ends_with: z.optional(z.string()), - call_type_like: z.optional(z.string()), - call_type_not_like: z.optional(z.string()), - call_type_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - call_type_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - function_selector_eq: z.optional(z.string()), - function_selector_ne: z.optional(z.string()), - function_selector_contains: z.optional(z.string()), - function_selector_starts_with: z.optional(z.string()), - function_selector_ends_with: z.optional(z.string()), - function_selector_like: z.optional(z.string()), - function_selector_not_like: z.optional(z.string()), - function_selector_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - function_selector_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - opcode_count_eq: z.optional( + gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_compute_eq: z.optional( z.coerce .bigint() .check( @@ -112165,7 +115730,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_ne: z.optional( + gas_compute_ne: z.optional( z.coerce .bigint() .check( @@ -112175,7 +115740,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_lt: z.optional( + gas_compute_lt: z.optional( z.coerce .bigint() .check( @@ -112185,7 +115750,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_lte: z.optional( + gas_compute_lte: z.optional( z.coerce .bigint() .check( @@ -112195,7 +115760,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_gt: z.optional( + gas_compute_gt: z.optional( z.coerce .bigint() .check( @@ -112205,7 +115770,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_gte: z.optional( + gas_compute_gte: z.optional( z.coerce .bigint() .check( @@ -112215,7 +115780,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_between_min: z.optional( + gas_compute_between_min: z.optional( z.coerce .bigint() .check( @@ -112225,7 +115790,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_between_max_value: z.optional( + gas_compute_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112235,9 +115800,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - opcode_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - error_count_eq: z.optional( + gas_compute_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_compute_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_eq: z.optional( z.coerce .bigint() .check( @@ -112247,7 +115812,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_ne: z.optional( + gas_memory_ne: z.optional( z.coerce .bigint() .check( @@ -112257,7 +115822,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_lt: z.optional( + gas_memory_lt: z.optional( z.coerce .bigint() .check( @@ -112267,7 +115832,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_lte: z.optional( + gas_memory_lte: z.optional( z.coerce .bigint() .check( @@ -112277,7 +115842,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_gt: z.optional( + gas_memory_gt: z.optional( z.coerce .bigint() .check( @@ -112287,7 +115852,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_gte: z.optional( + gas_memory_gte: z.optional( z.coerce .bigint() .check( @@ -112297,7 +115862,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_between_min: z.optional( + gas_memory_between_min: z.optional( z.coerce .bigint() .check( @@ -112307,7 +115872,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_between_max_value: z.optional( + gas_memory_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112317,9 +115882,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - error_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - error_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_eq: z.optional( + gas_memory_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_eq: z.optional( z.coerce .bigint() .check( @@ -112329,7 +115894,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_ne: z.optional( + gas_address_access_ne: z.optional( z.coerce .bigint() .check( @@ -112339,7 +115904,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_lt: z.optional( + gas_address_access_lt: z.optional( z.coerce .bigint() .check( @@ -112349,7 +115914,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_lte: z.optional( + gas_address_access_lte: z.optional( z.coerce .bigint() .check( @@ -112359,7 +115924,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_gt: z.optional( + gas_address_access_gt: z.optional( z.coerce .bigint() .check( @@ -112369,7 +115934,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_gte: z.optional( + gas_address_access_gte: z.optional( z.coerce .bigint() .check( @@ -112379,7 +115944,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_between_min: z.optional( + gas_address_access_between_min: z.optional( z.coerce .bigint() .check( @@ -112389,7 +115954,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_between_max_value: z.optional( + gas_address_access_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112399,9 +115964,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_cumulative_eq: z.optional( + gas_address_access_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_eq: z.optional( z.coerce .bigint() .check( @@ -112411,7 +115976,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_ne: z.optional( + gas_state_growth_ne: z.optional( z.coerce .bigint() .check( @@ -112421,7 +115986,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_lt: z.optional( + gas_state_growth_lt: z.optional( z.coerce .bigint() .check( @@ -112431,7 +115996,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_lte: z.optional( + gas_state_growth_lte: z.optional( z.coerce .bigint() .check( @@ -112441,7 +116006,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_gt: z.optional( + gas_state_growth_gt: z.optional( z.coerce .bigint() .check( @@ -112451,7 +116016,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_gte: z.optional( + gas_state_growth_gte: z.optional( z.coerce .bigint() .check( @@ -112461,7 +116026,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_between_min: z.optional( + gas_state_growth_between_min: z.optional( z.coerce .bigint() .check( @@ -112471,7 +116036,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_between_max_value: z.optional( + gas_state_growth_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112481,9 +116046,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_cumulative_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_refund_eq: z.optional( + gas_state_growth_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_eq: z.optional( z.coerce .bigint() .check( @@ -112493,7 +116058,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_ne: z.optional( + gas_history_ne: z.optional( z.coerce .bigint() .check( @@ -112503,7 +116068,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_lt: z.optional( + gas_history_lt: z.optional( z.coerce .bigint() .check( @@ -112513,7 +116078,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_lte: z.optional( + gas_history_lte: z.optional( z.coerce .bigint() .check( @@ -112523,7 +116088,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_gt: z.optional( + gas_history_gt: z.optional( z.coerce .bigint() .check( @@ -112533,7 +116098,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_gte: z.optional( + gas_history_gte: z.optional( z.coerce .bigint() .check( @@ -112543,7 +116108,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_between_min: z.optional( + gas_history_between_min: z.optional( z.coerce .bigint() .check( @@ -112553,7 +116118,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_between_max_value: z.optional( + gas_history_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112563,9 +116128,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_refund_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - intrinsic_gas_eq: z.optional( + gas_history_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_eq: z.optional( z.coerce .bigint() .check( @@ -112575,7 +116140,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_ne: z.optional( + gas_bloom_topics_ne: z.optional( z.coerce .bigint() .check( @@ -112585,7 +116150,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_lt: z.optional( + gas_bloom_topics_lt: z.optional( z.coerce .bigint() .check( @@ -112595,7 +116160,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_lte: z.optional( + gas_bloom_topics_lte: z.optional( z.coerce .bigint() .check( @@ -112605,7 +116170,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_gt: z.optional( + gas_bloom_topics_gt: z.optional( z.coerce .bigint() .check( @@ -112615,7 +116180,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_gte: z.optional( + gas_bloom_topics_gte: z.optional( z.coerce .bigint() .check( @@ -112625,7 +116190,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_between_min: z.optional( + gas_bloom_topics_between_min: z.optional( z.coerce .bigint() .check( @@ -112635,7 +116200,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_between_max_value: z.optional( + gas_bloom_topics_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112645,9 +116210,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - intrinsic_gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - receipt_gas_used_eq: z.optional( + gas_bloom_topics_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_eq: z.optional( z.coerce .bigint() .check( @@ -112657,7 +116222,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_ne: z.optional( + gas_block_size_ne: z.optional( z.coerce .bigint() .check( @@ -112667,7 +116232,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_lt: z.optional( + gas_block_size_lt: z.optional( z.coerce .bigint() .check( @@ -112677,7 +116242,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_lte: z.optional( + gas_block_size_lte: z.optional( z.coerce .bigint() .check( @@ -112687,7 +116252,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_gt: z.optional( + gas_block_size_gt: z.optional( z.coerce .bigint() .check( @@ -112697,7 +116262,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_gte: z.optional( + gas_block_size_gte: z.optional( z.coerce .bigint() .check( @@ -112707,7 +116272,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_between_min: z.optional( + gas_block_size_between_min: z.optional( z.coerce .bigint() .check( @@ -112717,7 +116282,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_between_max_value: z.optional( + gas_block_size_between_max_value: z.optional( z.coerce .bigint() .check( @@ -112727,8 +116292,8 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - receipt_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -112746,9 +116311,10 @@ export const zIntTransactionCallFrameServiceListData = z.object({ /** * OK */ -export const zIntTransactionCallFrameServiceListResponse = zListIntTransactionCallFrameResponse; +export const zIntTransactionCallFrameOpcodeResourceGasServiceListResponse = + zListIntTransactionCallFrameOpcodeResourceGasResponse; -export const zIntTransactionCallFrameServiceGetData = z.object({ +export const zIntTransactionCallFrameOpcodeResourceGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -112766,9 +116332,10 @@ export const zIntTransactionCallFrameServiceGetData = z.object({ /** * OK */ -export const zIntTransactionCallFrameServiceGetResponse = zGetIntTransactionCallFrameResponse; +export const zIntTransactionCallFrameOpcodeResourceGasServiceGetResponse = + zGetIntTransactionCallFrameOpcodeResourceGasResponse; -export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ +export const zIntTransactionOpcodeGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -112864,72 +116431,6 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ transaction_hash_not_like: z.optional(z.string()), transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - call_frame_id_eq: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_ne: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_lt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_lte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_gt: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_gte: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_between_min: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_between_max_value: z.optional( - z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - call_frame_id_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - call_frame_id_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), opcode_eq: z.optional(z.string()), opcode_ne: z.optional(z.string()), opcode_contains: z.optional(z.string()), @@ -113425,9 +116926,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ /** * OK */ -export const zIntTransactionCallFrameOpcodeGasServiceListResponse = zListIntTransactionCallFrameOpcodeGasResponse; +export const zIntTransactionOpcodeGasServiceListResponse = zListIntTransactionOpcodeGasResponse; -export const zIntTransactionCallFrameOpcodeGasServiceGetData = z.object({ +export const zIntTransactionOpcodeGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -113445,9 +116946,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceGetData = z.object({ /** * OK */ -export const zIntTransactionCallFrameOpcodeGasServiceGetResponse = zGetIntTransactionCallFrameOpcodeGasResponse; +export const zIntTransactionOpcodeGasServiceGetResponse = zGetIntTransactionOpcodeGasResponse; -export const zIntTransactionOpcodeGasServiceListData = z.object({ +export const zIntTransactionResourceGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -113543,15 +117044,6 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ transaction_hash_not_like: z.optional(z.string()), transaction_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), transaction_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - opcode_eq: z.optional(z.string()), - opcode_ne: z.optional(z.string()), - opcode_contains: z.optional(z.string()), - opcode_starts_with: z.optional(z.string()), - opcode_ends_with: z.optional(z.string()), - opcode_like: z.optional(z.string()), - opcode_not_like: z.optional(z.string()), - opcode_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - opcode_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), meta_network_name_eq: z.optional(z.string()), meta_network_name_ne: z.optional(z.string()), meta_network_name_contains: z.optional(z.string()), @@ -113693,7 +117185,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ ), transaction_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), transaction_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - count_eq: z.optional( + gas_compute_eq: z.optional( z.coerce .bigint() .check( @@ -113703,7 +117195,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_ne: z.optional( + gas_compute_ne: z.optional( z.coerce .bigint() .check( @@ -113713,7 +117205,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_lt: z.optional( + gas_compute_lt: z.optional( z.coerce .bigint() .check( @@ -113723,7 +117215,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_lte: z.optional( + gas_compute_lte: z.optional( z.coerce .bigint() .check( @@ -113733,7 +117225,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_gt: z.optional( + gas_compute_gt: z.optional( z.coerce .bigint() .check( @@ -113743,7 +117235,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_gte: z.optional( + gas_compute_gte: z.optional( z.coerce .bigint() .check( @@ -113753,7 +117245,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_between_min: z.optional( + gas_compute_between_min: z.optional( z.coerce .bigint() .check( @@ -113763,7 +117255,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_between_max_value: z.optional( + gas_compute_between_max_value: z.optional( z.coerce .bigint() .check( @@ -113773,9 +117265,9 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_eq: z.optional( + gas_compute_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_compute_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_eq: z.optional( z.coerce .bigint() .check( @@ -113785,7 +117277,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_ne: z.optional( + gas_memory_ne: z.optional( z.coerce .bigint() .check( @@ -113795,7 +117287,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_lt: z.optional( + gas_memory_lt: z.optional( z.coerce .bigint() .check( @@ -113805,7 +117297,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_lte: z.optional( + gas_memory_lte: z.optional( z.coerce .bigint() .check( @@ -113815,7 +117307,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_gt: z.optional( + gas_memory_gt: z.optional( z.coerce .bigint() .check( @@ -113825,7 +117317,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_gte: z.optional( + gas_memory_gte: z.optional( z.coerce .bigint() .check( @@ -113835,7 +117327,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_between_min: z.optional( + gas_memory_between_min: z.optional( z.coerce .bigint() .check( @@ -113845,7 +117337,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_between_max_value: z.optional( + gas_memory_between_max_value: z.optional( z.coerce .bigint() .check( @@ -113855,9 +117347,9 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_cumulative_eq: z.optional( + gas_memory_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_memory_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_eq: z.optional( z.coerce .bigint() .check( @@ -113867,7 +117359,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_ne: z.optional( + gas_address_access_ne: z.optional( z.coerce .bigint() .check( @@ -113877,7 +117369,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_lt: z.optional( + gas_address_access_lt: z.optional( z.coerce .bigint() .check( @@ -113887,7 +117379,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_lte: z.optional( + gas_address_access_lte: z.optional( z.coerce .bigint() .check( @@ -113897,7 +117389,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_gt: z.optional( + gas_address_access_gt: z.optional( z.coerce .bigint() .check( @@ -113907,7 +117399,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_gte: z.optional( + gas_address_access_gte: z.optional( z.coerce .bigint() .check( @@ -113917,7 +117409,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_between_min: z.optional( + gas_address_access_between_min: z.optional( z.coerce .bigint() .check( @@ -113927,7 +117419,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_between_max_value: z.optional( + gas_address_access_between_max_value: z.optional( z.coerce .bigint() .check( @@ -113937,9 +117429,9 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - gas_cumulative_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - error_count_eq: z.optional( + gas_address_access_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_address_access_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_eq: z.optional( z.coerce .bigint() .check( @@ -113949,7 +117441,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_ne: z.optional( + gas_state_growth_ne: z.optional( z.coerce .bigint() .check( @@ -113959,7 +117451,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_lt: z.optional( + gas_state_growth_lt: z.optional( z.coerce .bigint() .check( @@ -113969,7 +117461,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_lte: z.optional( + gas_state_growth_lte: z.optional( z.coerce .bigint() .check( @@ -113979,7 +117471,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_gt: z.optional( + gas_state_growth_gt: z.optional( z.coerce .bigint() .check( @@ -113989,7 +117481,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_gte: z.optional( + gas_state_growth_gte: z.optional( z.coerce .bigint() .check( @@ -113999,7 +117491,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_between_min: z.optional( + gas_state_growth_between_min: z.optional( z.coerce .bigint() .check( @@ -114009,7 +117501,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_between_max_value: z.optional( + gas_state_growth_between_max_value: z.optional( z.coerce .bigint() .check( @@ -114019,8 +117511,336 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - error_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - error_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_state_growth_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_history_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_history_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_bloom_topics_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_bloom_topics_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_block_size_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_block_size_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_eq: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_ne: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_lte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gt: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_gte: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_between_min: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_between_max_value: z.optional( + z.coerce + .bigint() + .check( + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + gas_refund_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + gas_refund_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -114038,9 +117858,9 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ /** * OK */ -export const zIntTransactionOpcodeGasServiceListResponse = zListIntTransactionOpcodeGasResponse; +export const zIntTransactionResourceGasServiceListResponse = zListIntTransactionResourceGasResponse; -export const zIntTransactionOpcodeGasServiceGetData = z.object({ +export const zIntTransactionResourceGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -114058,4 +117878,4 @@ export const zIntTransactionOpcodeGasServiceGetData = z.object({ /** * OK */ -export const zIntTransactionOpcodeGasServiceGetResponse = zGetIntTransactionOpcodeGasResponse; +export const zIntTransactionResourceGasServiceGetResponse = zGetIntTransactionResourceGasResponse; diff --git a/src/pages/ethereum/execution/gas-profiler/CallPage.tsx b/src/pages/ethereum/execution/gas-profiler/CallPage.tsx index 34e85a1cc..526db138e 100644 --- a/src/pages/ethereum/execution/gas-profiler/CallPage.tsx +++ b/src/pages/ethereum/execution/gas-profiler/CallPage.tsx @@ -36,6 +36,7 @@ import { } from './components'; import { useNetwork } from '@/hooks/useNetwork'; import { CATEGORY_COLORS, getOpcodeCategory, getEtherscanBaseUrl, isMainnet } from './utils'; +import { isPrecompileAddress } from './utils/precompileNames'; import type { IntTransactionCallFrame } from '@/api/types.gen'; /** @@ -724,8 +725,8 @@ export function CallPage(): JSX.Element { - {/* Contract Storage CTA */} - {currentFrame.target_address && ( + {/* Contract Storage CTA - hide for precompiles (no storage) */} + {currentFrame.target_address && !isPrecompileAddress(currentFrame.target_address) && (
0; const isExpanded = expandedNodes.has(callId); const hasError = (frame.error_count ?? 0) > 0; + const isPrecompile = isPrecompileAddress(frame.target_address); // Look up opcode stats for this specific call frame const opcodeStats = allOpcodeStats?.get(callId); @@ -411,7 +413,7 @@ function TraceRow({ {/* Contract/Function name */} - {node.contractName && ( + {node.contractName && !isPrecompile && ( )} - {node.contractName && .} + {node.contractName && !isPrecompile && .} - {node.functionName || (node.contractName ? '(fallback)' : displayLabel)} + {isPrecompile ? displayLabel : node.functionName || (node.contractName ? '(fallback)' : displayLabel)} @@ -524,11 +526,11 @@ function TraceRow({ {/* Spacer */} - {/* Storage link */} - {frame.target_address && } + {/* Storage link - hide for precompiles (no storage) */} + {frame.target_address && !isPrecompile && } - {/* Opcode breakdown toggle - only for actual calls (not root) */} - {frame.call_type && ( + {/* Opcode breakdown toggle - hide for precompiles (no opcodes) */} + {frame.call_type && !isPrecompile && (