From e20a57580e5728fd7e79bb26304ff09e52938e47 Mon Sep 17 00:00:00 2001 From: Matty Evans Date: Thu, 26 Feb 2026 16:29:35 +1000 Subject: [PATCH] feat: gas profiler - receipt size --- src/api/@tanstack/react-query.gen.ts | 264 + src/api/index.ts | 60 + src/api/sdk.gen.ts | 192 + src/api/types.gen.ts | 2600 +++ src/api/zod.gen.ts | 16575 ++++++++++------ .../execution/gas-profiler/BlockPage.tsx | 77 +- .../execution/gas-profiler/HomePage.tsx | 307 +- .../gas-profiler/TransactionPage.tsx | 145 +- .../TransactionSummaryCard.tsx | 10 + .../TransactionSummaryCard.types.ts | 4 + .../execution/gas-profiler/hooks/index.ts | 4 + .../hooks/useBlockReceiptSizes.ts | 70 + .../hooks/useTransactionReceiptSize.ts | 58 + src/utils/number.ts | 17 + 14 files changed, 14149 insertions(+), 6234 deletions(-) create mode 100644 src/pages/ethereum/execution/gas-profiler/hooks/useBlockReceiptSizes.ts create mode 100644 src/pages/ethereum/execution/gas-profiler/hooks/useTransactionReceiptSize.ts diff --git a/src/api/@tanstack/react-query.gen.ts b/src/api/@tanstack/react-query.gen.ts index 9edbefa57..50abf2f97 100644 --- a/src/api/@tanstack/react-query.gen.ts +++ b/src/api/@tanstack/react-query.gen.ts @@ -154,6 +154,10 @@ import { fctExecutionGasUsedDailyServiceList, fctExecutionGasUsedHourlyServiceGet, fctExecutionGasUsedHourlyServiceList, + fctExecutionReceiptSizeDailyServiceGet, + fctExecutionReceiptSizeDailyServiceList, + fctExecutionReceiptSizeHourlyServiceGet, + fctExecutionReceiptSizeHourlyServiceList, fctExecutionStateSizeDailyServiceGet, fctExecutionStateSizeDailyServiceList, fctExecutionStateSizeHourlyServiceGet, @@ -270,6 +274,8 @@ import { intBlockOpcodeGasServiceList, intBlockProposerCanonicalServiceGet, intBlockProposerCanonicalServiceList, + intBlockReceiptSizeServiceGet, + intBlockReceiptSizeServiceList, intBlockResourceGasServiceGet, intBlockResourceGasServiceList, intContractCreationServiceGet, @@ -372,6 +378,8 @@ import { intTransactionCallFrameServiceList, intTransactionOpcodeGasServiceGet, intTransactionOpcodeGasServiceList, + intTransactionReceiptSizeServiceGet, + intTransactionReceiptSizeServiceList, intTransactionResourceGasServiceGet, intTransactionResourceGasServiceList, type Options, @@ -827,6 +835,18 @@ import type { FctExecutionGasUsedHourlyServiceListData, FctExecutionGasUsedHourlyServiceListError, FctExecutionGasUsedHourlyServiceListResponse, + FctExecutionReceiptSizeDailyServiceGetData, + FctExecutionReceiptSizeDailyServiceGetError, + FctExecutionReceiptSizeDailyServiceGetResponse, + FctExecutionReceiptSizeDailyServiceListData, + FctExecutionReceiptSizeDailyServiceListError, + FctExecutionReceiptSizeDailyServiceListResponse, + FctExecutionReceiptSizeHourlyServiceGetData, + FctExecutionReceiptSizeHourlyServiceGetError, + FctExecutionReceiptSizeHourlyServiceGetResponse, + FctExecutionReceiptSizeHourlyServiceListData, + FctExecutionReceiptSizeHourlyServiceListError, + FctExecutionReceiptSizeHourlyServiceListResponse, FctExecutionStateSizeDailyServiceGetData, FctExecutionStateSizeDailyServiceGetError, FctExecutionStateSizeDailyServiceGetResponse, @@ -1175,6 +1195,12 @@ import type { IntBlockProposerCanonicalServiceListData, IntBlockProposerCanonicalServiceListError, IntBlockProposerCanonicalServiceListResponse, + IntBlockReceiptSizeServiceGetData, + IntBlockReceiptSizeServiceGetError, + IntBlockReceiptSizeServiceGetResponse, + IntBlockReceiptSizeServiceListData, + IntBlockReceiptSizeServiceListError, + IntBlockReceiptSizeServiceListResponse, IntBlockResourceGasServiceGetData, IntBlockResourceGasServiceGetError, IntBlockResourceGasServiceGetResponse, @@ -1481,6 +1507,12 @@ import type { IntTransactionOpcodeGasServiceListData, IntTransactionOpcodeGasServiceListError, IntTransactionOpcodeGasServiceListResponse, + IntTransactionReceiptSizeServiceGetData, + IntTransactionReceiptSizeServiceGetError, + IntTransactionReceiptSizeServiceGetResponse, + IntTransactionReceiptSizeServiceListData, + IntTransactionReceiptSizeServiceListError, + IntTransactionReceiptSizeServiceListResponse, IntTransactionResourceGasServiceGetData, IntTransactionResourceGasServiceGetError, IntTransactionResourceGasServiceGetResponse, @@ -5887,6 +5919,126 @@ export const fctExecutionGasUsedHourlyServiceGetOptions = (options: Options +) => createQueryKey('fctExecutionReceiptSizeDailyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctExecutionReceiptSizeDailyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctExecutionReceiptSizeDailyServiceListResponse, + FctExecutionReceiptSizeDailyServiceListError, + FctExecutionReceiptSizeDailyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctExecutionReceiptSizeDailyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctExecutionReceiptSizeDailyServiceListQueryKey(options), + }); + +export const fctExecutionReceiptSizeDailyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctExecutionReceiptSizeDailyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctExecutionReceiptSizeDailyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctExecutionReceiptSizeDailyServiceGetResponse, + FctExecutionReceiptSizeDailyServiceGetError, + FctExecutionReceiptSizeDailyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctExecutionReceiptSizeDailyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctExecutionReceiptSizeDailyServiceGetQueryKey(options), + }); + +export const fctExecutionReceiptSizeHourlyServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctExecutionReceiptSizeHourlyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctExecutionReceiptSizeHourlyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctExecutionReceiptSizeHourlyServiceListResponse, + FctExecutionReceiptSizeHourlyServiceListError, + FctExecutionReceiptSizeHourlyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctExecutionReceiptSizeHourlyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctExecutionReceiptSizeHourlyServiceListQueryKey(options), + }); + +export const fctExecutionReceiptSizeHourlyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctExecutionReceiptSizeHourlyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctExecutionReceiptSizeHourlyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctExecutionReceiptSizeHourlyServiceGetResponse, + FctExecutionReceiptSizeHourlyServiceGetError, + FctExecutionReceiptSizeHourlyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctExecutionReceiptSizeHourlyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctExecutionReceiptSizeHourlyServiceGetQueryKey(options), + }); + export const fctExecutionStateSizeDailyServiceListQueryKey = ( options?: Options ) => createQueryKey('fctExecutionStateSizeDailyServiceList', options); @@ -9212,6 +9364,60 @@ export const intBlockProposerCanonicalServiceGetOptions = (options: Options) => + createQueryKey('intBlockReceiptSizeServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const intBlockReceiptSizeServiceListOptions = (options?: Options) => + queryOptions< + IntBlockReceiptSizeServiceListResponse, + IntBlockReceiptSizeServiceListError, + IntBlockReceiptSizeServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intBlockReceiptSizeServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intBlockReceiptSizeServiceListQueryKey(options), + }); + +export const intBlockReceiptSizeServiceGetQueryKey = (options: Options) => + createQueryKey('intBlockReceiptSizeServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intBlockReceiptSizeServiceGetOptions = (options: Options) => + queryOptions< + IntBlockReceiptSizeServiceGetResponse, + IntBlockReceiptSizeServiceGetError, + IntBlockReceiptSizeServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intBlockReceiptSizeServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intBlockReceiptSizeServiceGetQueryKey(options), + }); + export const intBlockResourceGasServiceListQueryKey = (options?: Options) => createQueryKey('intBlockResourceGasServiceList', options); @@ -12158,6 +12364,64 @@ export const intTransactionOpcodeGasServiceGetOptions = (options: Options +) => createQueryKey('intTransactionReceiptSizeServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const intTransactionReceiptSizeServiceListOptions = ( + options?: Options +) => + queryOptions< + IntTransactionReceiptSizeServiceListResponse, + IntTransactionReceiptSizeServiceListError, + IntTransactionReceiptSizeServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionReceiptSizeServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionReceiptSizeServiceListQueryKey(options), + }); + +export const intTransactionReceiptSizeServiceGetQueryKey = ( + options: Options +) => createQueryKey('intTransactionReceiptSizeServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionReceiptSizeServiceGetOptions = (options: Options) => + queryOptions< + IntTransactionReceiptSizeServiceGetResponse, + IntTransactionReceiptSizeServiceGetError, + IntTransactionReceiptSizeServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await intTransactionReceiptSizeServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: intTransactionReceiptSizeServiceGetQueryKey(options), + }); + export const intTransactionResourceGasServiceListQueryKey = ( options?: Options ) => createQueryKey('intTransactionResourceGasServiceList', options); diff --git a/src/api/index.ts b/src/api/index.ts index b9ca6eead..ab06b3017 100644 --- a/src/api/index.ts +++ b/src/api/index.ts @@ -151,6 +151,10 @@ export { fctExecutionGasUsedDailyServiceList, fctExecutionGasUsedHourlyServiceGet, fctExecutionGasUsedHourlyServiceList, + fctExecutionReceiptSizeDailyServiceGet, + fctExecutionReceiptSizeDailyServiceList, + fctExecutionReceiptSizeHourlyServiceGet, + fctExecutionReceiptSizeHourlyServiceList, fctExecutionStateSizeDailyServiceGet, fctExecutionStateSizeDailyServiceList, fctExecutionStateSizeHourlyServiceGet, @@ -267,6 +271,8 @@ export { intBlockOpcodeGasServiceList, intBlockProposerCanonicalServiceGet, intBlockProposerCanonicalServiceList, + intBlockReceiptSizeServiceGet, + intBlockReceiptSizeServiceList, intBlockResourceGasServiceGet, intBlockResourceGasServiceList, intContractCreationServiceGet, @@ -369,6 +375,8 @@ export { intTransactionCallFrameServiceList, intTransactionOpcodeGasServiceGet, intTransactionOpcodeGasServiceList, + intTransactionReceiptSizeServiceGet, + intTransactionReceiptSizeServiceList, intTransactionResourceGasServiceGet, intTransactionResourceGasServiceList, type Options, @@ -1200,6 +1208,28 @@ export type { FctExecutionGasUsedHourlyServiceListErrors, FctExecutionGasUsedHourlyServiceListResponse, FctExecutionGasUsedHourlyServiceListResponses, + FctExecutionReceiptSizeDaily, + FctExecutionReceiptSizeDailyServiceGetData, + FctExecutionReceiptSizeDailyServiceGetError, + FctExecutionReceiptSizeDailyServiceGetErrors, + FctExecutionReceiptSizeDailyServiceGetResponse, + FctExecutionReceiptSizeDailyServiceGetResponses, + FctExecutionReceiptSizeDailyServiceListData, + FctExecutionReceiptSizeDailyServiceListError, + FctExecutionReceiptSizeDailyServiceListErrors, + FctExecutionReceiptSizeDailyServiceListResponse, + FctExecutionReceiptSizeDailyServiceListResponses, + FctExecutionReceiptSizeHourly, + FctExecutionReceiptSizeHourlyServiceGetData, + FctExecutionReceiptSizeHourlyServiceGetError, + FctExecutionReceiptSizeHourlyServiceGetErrors, + FctExecutionReceiptSizeHourlyServiceGetResponse, + FctExecutionReceiptSizeHourlyServiceGetResponses, + FctExecutionReceiptSizeHourlyServiceListData, + FctExecutionReceiptSizeHourlyServiceListError, + FctExecutionReceiptSizeHourlyServiceListErrors, + FctExecutionReceiptSizeHourlyServiceListResponse, + FctExecutionReceiptSizeHourlyServiceListResponses, FctExecutionStateSizeDaily, FctExecutionStateSizeDailyServiceGetData, FctExecutionStateSizeDailyServiceGetError, @@ -1770,6 +1800,8 @@ export type { GetFctExecutionGasLimitSignallingHourlyResponse, GetFctExecutionGasUsedDailyResponse, GetFctExecutionGasUsedHourlyResponse, + GetFctExecutionReceiptSizeDailyResponse, + GetFctExecutionReceiptSizeHourlyResponse, GetFctExecutionStateSizeDailyResponse, GetFctExecutionStateSizeHourlyResponse, GetFctExecutionTpsDailyResponse, @@ -1828,6 +1860,7 @@ export type { GetIntBlockMevCanonicalResponse, GetIntBlockOpcodeGasResponse, GetIntBlockProposerCanonicalResponse, + GetIntBlockReceiptSizeResponse, GetIntBlockResourceGasResponse, GetIntContractCreationResponse, GetIntContractSelfdestructResponse, @@ -1879,6 +1912,7 @@ export type { GetIntTransactionCallFrameOpcodeResourceGasResponse, GetIntTransactionCallFrameResponse, GetIntTransactionOpcodeGasResponse, + GetIntTransactionReceiptSizeResponse, GetIntTransactionResourceGasResponse, GoogleProtobufAny, IntAddressFirstAccess, @@ -2024,6 +2058,17 @@ export type { IntBlockProposerCanonicalServiceListErrors, IntBlockProposerCanonicalServiceListResponse, IntBlockProposerCanonicalServiceListResponses, + IntBlockReceiptSize, + IntBlockReceiptSizeServiceGetData, + IntBlockReceiptSizeServiceGetError, + IntBlockReceiptSizeServiceGetErrors, + IntBlockReceiptSizeServiceGetResponse, + IntBlockReceiptSizeServiceGetResponses, + IntBlockReceiptSizeServiceListData, + IntBlockReceiptSizeServiceListError, + IntBlockReceiptSizeServiceListErrors, + IntBlockReceiptSizeServiceListResponse, + IntBlockReceiptSizeServiceListResponses, IntBlockResourceGas, IntBlockResourceGasServiceGetData, IntBlockResourceGasServiceGetError, @@ -2585,6 +2630,17 @@ export type { IntTransactionOpcodeGasServiceListErrors, IntTransactionOpcodeGasServiceListResponse, IntTransactionOpcodeGasServiceListResponses, + IntTransactionReceiptSize, + IntTransactionReceiptSizeServiceGetData, + IntTransactionReceiptSizeServiceGetError, + IntTransactionReceiptSizeServiceGetErrors, + IntTransactionReceiptSizeServiceGetResponse, + IntTransactionReceiptSizeServiceGetResponses, + IntTransactionReceiptSizeServiceListData, + IntTransactionReceiptSizeServiceListError, + IntTransactionReceiptSizeServiceListErrors, + IntTransactionReceiptSizeServiceListResponse, + IntTransactionReceiptSizeServiceListResponses, IntTransactionResourceGas, IntTransactionResourceGasServiceGetData, IntTransactionResourceGasServiceGetError, @@ -2671,6 +2727,8 @@ export type { ListFctExecutionGasLimitSignallingHourlyResponse, ListFctExecutionGasUsedDailyResponse, ListFctExecutionGasUsedHourlyResponse, + ListFctExecutionReceiptSizeDailyResponse, + ListFctExecutionReceiptSizeHourlyResponse, ListFctExecutionStateSizeDailyResponse, ListFctExecutionStateSizeHourlyResponse, ListFctExecutionTpsDailyResponse, @@ -2729,6 +2787,7 @@ export type { ListIntBlockMevCanonicalResponse, ListIntBlockOpcodeGasResponse, ListIntBlockProposerCanonicalResponse, + ListIntBlockReceiptSizeResponse, ListIntBlockResourceGasResponse, ListIntContractCreationResponse, ListIntContractSelfdestructResponse, @@ -2780,6 +2839,7 @@ export type { ListIntTransactionCallFrameOpcodeResourceGasResponse, ListIntTransactionCallFrameResponse, ListIntTransactionOpcodeGasResponse, + ListIntTransactionReceiptSizeResponse, ListIntTransactionResourceGasResponse, Status, } from './types.gen'; diff --git a/src/api/sdk.gen.ts b/src/api/sdk.gen.ts index bb8898229..fcb9c8161 100644 --- a/src/api/sdk.gen.ts +++ b/src/api/sdk.gen.ts @@ -453,6 +453,18 @@ import type { FctExecutionGasUsedHourlyServiceListData, FctExecutionGasUsedHourlyServiceListErrors, FctExecutionGasUsedHourlyServiceListResponses, + FctExecutionReceiptSizeDailyServiceGetData, + FctExecutionReceiptSizeDailyServiceGetErrors, + FctExecutionReceiptSizeDailyServiceGetResponses, + FctExecutionReceiptSizeDailyServiceListData, + FctExecutionReceiptSizeDailyServiceListErrors, + FctExecutionReceiptSizeDailyServiceListResponses, + FctExecutionReceiptSizeHourlyServiceGetData, + FctExecutionReceiptSizeHourlyServiceGetErrors, + FctExecutionReceiptSizeHourlyServiceGetResponses, + FctExecutionReceiptSizeHourlyServiceListData, + FctExecutionReceiptSizeHourlyServiceListErrors, + FctExecutionReceiptSizeHourlyServiceListResponses, FctExecutionStateSizeDailyServiceGetData, FctExecutionStateSizeDailyServiceGetErrors, FctExecutionStateSizeDailyServiceGetResponses, @@ -801,6 +813,12 @@ import type { IntBlockProposerCanonicalServiceListData, IntBlockProposerCanonicalServiceListErrors, IntBlockProposerCanonicalServiceListResponses, + IntBlockReceiptSizeServiceGetData, + IntBlockReceiptSizeServiceGetErrors, + IntBlockReceiptSizeServiceGetResponses, + IntBlockReceiptSizeServiceListData, + IntBlockReceiptSizeServiceListErrors, + IntBlockReceiptSizeServiceListResponses, IntBlockResourceGasServiceGetData, IntBlockResourceGasServiceGetErrors, IntBlockResourceGasServiceGetResponses, @@ -1107,6 +1125,12 @@ import type { IntTransactionOpcodeGasServiceListData, IntTransactionOpcodeGasServiceListErrors, IntTransactionOpcodeGasServiceListResponses, + IntTransactionReceiptSizeServiceGetData, + IntTransactionReceiptSizeServiceGetErrors, + IntTransactionReceiptSizeServiceGetResponses, + IntTransactionReceiptSizeServiceListData, + IntTransactionReceiptSizeServiceListErrors, + IntTransactionReceiptSizeServiceListResponses, IntTransactionResourceGasServiceGetData, IntTransactionResourceGasServiceGetErrors, IntTransactionResourceGasServiceGetResponses, @@ -1415,6 +1439,14 @@ import { zFctExecutionGasUsedHourlyServiceGetResponse, zFctExecutionGasUsedHourlyServiceListData, zFctExecutionGasUsedHourlyServiceListResponse, + zFctExecutionReceiptSizeDailyServiceGetData, + zFctExecutionReceiptSizeDailyServiceGetResponse, + zFctExecutionReceiptSizeDailyServiceListData, + zFctExecutionReceiptSizeDailyServiceListResponse, + zFctExecutionReceiptSizeHourlyServiceGetData, + zFctExecutionReceiptSizeHourlyServiceGetResponse, + zFctExecutionReceiptSizeHourlyServiceListData, + zFctExecutionReceiptSizeHourlyServiceListResponse, zFctExecutionStateSizeDailyServiceGetData, zFctExecutionStateSizeDailyServiceGetResponse, zFctExecutionStateSizeDailyServiceListData, @@ -1647,6 +1679,10 @@ import { zIntBlockProposerCanonicalServiceGetResponse, zIntBlockProposerCanonicalServiceListData, zIntBlockProposerCanonicalServiceListResponse, + zIntBlockReceiptSizeServiceGetData, + zIntBlockReceiptSizeServiceGetResponse, + zIntBlockReceiptSizeServiceListData, + zIntBlockReceiptSizeServiceListResponse, zIntBlockResourceGasServiceGetData, zIntBlockResourceGasServiceGetResponse, zIntBlockResourceGasServiceListData, @@ -1851,6 +1887,10 @@ import { zIntTransactionOpcodeGasServiceGetResponse, zIntTransactionOpcodeGasServiceListData, zIntTransactionOpcodeGasServiceListResponse, + zIntTransactionReceiptSizeServiceGetData, + zIntTransactionReceiptSizeServiceGetResponse, + zIntTransactionReceiptSizeServiceListData, + zIntTransactionReceiptSizeServiceListResponse, zIntTransactionResourceGasServiceGetData, zIntTransactionResourceGasServiceGetResponse, zIntTransactionResourceGasServiceListData, @@ -4700,6 +4740,82 @@ export const fctExecutionGasUsedHourlyServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + FctExecutionReceiptSizeDailyServiceListResponses, + FctExecutionReceiptSizeDailyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctExecutionReceiptSizeDailyServiceListData.parseAsync(data), + responseValidator: async data => await zFctExecutionReceiptSizeDailyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_execution_receipt_size_daily', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctExecutionReceiptSizeDailyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctExecutionReceiptSizeDailyServiceGetResponses, + FctExecutionReceiptSizeDailyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctExecutionReceiptSizeDailyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctExecutionReceiptSizeDailyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_execution_receipt_size_daily/{day_start_date}', + ...options, + }); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctExecutionReceiptSizeHourlyServiceList = ( + options?: Options +) => + (options?.client ?? client).get< + FctExecutionReceiptSizeHourlyServiceListResponses, + FctExecutionReceiptSizeHourlyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctExecutionReceiptSizeHourlyServiceListData.parseAsync(data), + responseValidator: async data => await zFctExecutionReceiptSizeHourlyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_execution_receipt_size_hourly', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctExecutionReceiptSizeHourlyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctExecutionReceiptSizeHourlyServiceGetResponses, + FctExecutionReceiptSizeHourlyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctExecutionReceiptSizeHourlyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctExecutionReceiptSizeHourlyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_execution_receipt_size_hourly/{hour_start_date_time}', + ...options, + }); + /** * List records * @@ -6896,6 +7012,44 @@ export const intBlockProposerCanonicalServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + IntBlockReceiptSizeServiceListResponses, + IntBlockReceiptSizeServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntBlockReceiptSizeServiceListData.parseAsync(data), + responseValidator: async data => await zIntBlockReceiptSizeServiceListResponse.parseAsync(data), + url: '/api/v1/int_block_receipt_size', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intBlockReceiptSizeServiceGet = ( + options: Options +) => + (options.client ?? client).get< + IntBlockReceiptSizeServiceGetResponses, + IntBlockReceiptSizeServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntBlockReceiptSizeServiceGetData.parseAsync(data), + responseValidator: async data => await zIntBlockReceiptSizeServiceGetResponse.parseAsync(data), + url: '/api/v1/int_block_receipt_size/{block_number}', + ...options, + }); + /** * List records * @@ -8832,6 +8986,44 @@ export const intTransactionOpcodeGasServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + IntTransactionReceiptSizeServiceListResponses, + IntTransactionReceiptSizeServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionReceiptSizeServiceListData.parseAsync(data), + responseValidator: async data => await zIntTransactionReceiptSizeServiceListResponse.parseAsync(data), + url: '/api/v1/int_transaction_receipt_size', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by block_number + */ +export const intTransactionReceiptSizeServiceGet = ( + options: Options +) => + (options.client ?? client).get< + IntTransactionReceiptSizeServiceGetResponses, + IntTransactionReceiptSizeServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zIntTransactionReceiptSizeServiceGetData.parseAsync(data), + responseValidator: async data => await zIntTransactionReceiptSizeServiceGetResponse.parseAsync(data), + url: '/api/v1/int_transaction_receipt_size/{block_number}', + ...options, + }); + /** * List records * diff --git a/src/api/types.gen.ts b/src/api/types.gen.ts index 667f4a5ac..c7273f0a8 100644 --- a/src/api/types.gen.ts +++ b/src/api/types.gen.ts @@ -3751,6 +3751,180 @@ export type FctExecutionGasUsedHourly = { upper_band_gas_used?: number; }; +export type FctExecutionReceiptSizeDaily = { + /** + * Average logs per transaction + */ + avg_log_count_per_transaction?: number; + /** + * Average total receipt bytes per block + */ + avg_receipt_bytes_per_block?: number; + /** + * Average receipt bytes per transaction + */ + avg_receipt_bytes_per_transaction?: number; + /** + * Number of blocks in this day + */ + block_count?: number; + /** + * Running total of receipt bytes since genesis + */ + cumulative_receipt_bytes?: number; + /** + * The start date of the day + */ + day_start_date?: string; + /** + * Lower Bollinger band (avg - 2*stddev) + */ + lower_band_receipt_bytes_per_block?: number; + /** + * Maximum total receipt bytes in a single block + */ + max_receipt_bytes_per_block?: number; + /** + * Minimum total receipt bytes in a single block + */ + min_receipt_bytes_per_block?: number; + /** + * 7-day moving average of receipt bytes per block + */ + moving_avg_receipt_bytes_per_block?: number; + /** + * 5th percentile of total receipt bytes per block + */ + p05_receipt_bytes_per_block?: number; + /** + * 50th percentile of total receipt bytes per block + */ + p50_receipt_bytes_per_block?: number; + /** + * 50th percentile of receipt bytes per transaction + */ + p50_receipt_bytes_per_transaction?: number; + /** + * 95th percentile of total receipt bytes per block + */ + p95_receipt_bytes_per_block?: number; + /** + * 95th percentile of receipt bytes per transaction + */ + p95_receipt_bytes_per_transaction?: number; + /** + * Standard deviation of total receipt bytes per block + */ + stddev_receipt_bytes_per_block?: number; + /** + * Total logs emitted across all transactions + */ + total_log_count?: number; + /** + * Total receipt bytes across all blocks + */ + total_receipt_bytes?: number; + /** + * Number of transactions in this day + */ + transaction_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; + /** + * Upper Bollinger band (avg + 2*stddev) + */ + upper_band_receipt_bytes_per_block?: number; +}; + +export type FctExecutionReceiptSizeHourly = { + /** + * Average logs per transaction + */ + avg_log_count_per_transaction?: number; + /** + * Average total receipt bytes per block + */ + avg_receipt_bytes_per_block?: number; + /** + * Average receipt bytes per transaction + */ + avg_receipt_bytes_per_transaction?: number; + /** + * Number of blocks in this hour + */ + block_count?: number; + /** + * Running total of receipt bytes since genesis + */ + cumulative_receipt_bytes?: number; + /** + * The start time of the hour + */ + hour_start_date_time?: number; + /** + * Lower Bollinger band (avg - 2*stddev) + */ + lower_band_receipt_bytes_per_block?: number; + /** + * Maximum total receipt bytes in a single block + */ + max_receipt_bytes_per_block?: number; + /** + * Minimum total receipt bytes in a single block + */ + min_receipt_bytes_per_block?: number; + /** + * 6-hour moving average of receipt bytes per block + */ + moving_avg_receipt_bytes_per_block?: number; + /** + * 5th percentile of total receipt bytes per block + */ + p05_receipt_bytes_per_block?: number; + /** + * 50th percentile of total receipt bytes per block + */ + p50_receipt_bytes_per_block?: number; + /** + * 50th percentile of receipt bytes per transaction + */ + p50_receipt_bytes_per_transaction?: number; + /** + * 95th percentile of total receipt bytes per block + */ + p95_receipt_bytes_per_block?: number; + /** + * 95th percentile of receipt bytes per transaction + */ + p95_receipt_bytes_per_transaction?: number; + /** + * Standard deviation of total receipt bytes per block + */ + stddev_receipt_bytes_per_block?: number; + /** + * Total logs emitted across all transactions + */ + total_log_count?: number; + /** + * Total receipt bytes across all blocks + */ + total_receipt_bytes?: number; + /** + * Number of transactions in this hour + */ + transaction_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; + /** + * Upper Bollinger band (avg + 2*stddev) + */ + upper_band_receipt_bytes_per_block?: number; +}; + export type FctExecutionStateSizeDaily = { /** * Account bytes at end of day @@ -6283,6 +6457,20 @@ export type GetFctExecutionGasUsedHourlyResponse = { item?: FctExecutionGasUsedHourly; }; +/** + * Response for getting a single fct_execution_receipt_size_daily record + */ +export type GetFctExecutionReceiptSizeDailyResponse = { + item?: FctExecutionReceiptSizeDaily; +}; + +/** + * Response for getting a single fct_execution_receipt_size_hourly record + */ +export type GetFctExecutionReceiptSizeHourlyResponse = { + item?: FctExecutionReceiptSizeHourly; +}; + /** * Response for getting a single fct_execution_state_size_daily record */ @@ -6689,6 +6877,13 @@ export type GetIntBlockProposerCanonicalResponse = { item?: IntBlockProposerCanonical; }; +/** + * Response for getting a single int_block_receipt_size record + */ +export type GetIntBlockReceiptSizeResponse = { + item?: IntBlockReceiptSize; +}; + /** * Response for getting a single int_block_resource_gas record */ @@ -7046,6 +7241,13 @@ export type GetIntTransactionOpcodeGasResponse = { item?: IntTransactionOpcodeGas; }; +/** + * Response for getting a single int_transaction_receipt_size record + */ +export type GetIntTransactionReceiptSizeResponse = { + item?: IntTransactionReceiptSize; +}; + /** * Response for getting a single int_transaction_resource_gas record */ @@ -7671,6 +7873,57 @@ export type IntBlockProposerCanonical = { updated_date_time?: number; }; +export type IntBlockReceiptSize = { + /** + * Average receipt bytes per transaction in this block + */ + avg_receipt_bytes_per_transaction?: number; + /** + * The block number + */ + block_number?: number; + /** + * Total logs emitted across all transactions in the block + */ + log_count?: number; + /** + * Total raw bytes of log data fields across all transactions + */ + log_data_bytes?: number; + /** + * Total number of topics across all logs in the block + */ + log_topic_count?: number; + /** + * Largest single transaction receipt in this block + */ + max_receipt_bytes_per_transaction?: number; + /** + * The name of the network + */ + meta_network_name?: string; + /** + * 50th percentile of receipt bytes per transaction + */ + p50_receipt_bytes_per_transaction?: number; + /** + * 95th percentile of receipt bytes per transaction + */ + p95_receipt_bytes_per_transaction?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block + */ + receipt_bytes?: number; + /** + * Number of transactions in the block + */ + transaction_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + export type IntBlockResourceGas = { /** * The block number @@ -9812,6 +10065,45 @@ export type IntTransactionOpcodeGas = { updated_date_time?: number; }; +export type IntTransactionReceiptSize = { + /** + * The block number containing the transaction + */ + block_number?: number; + /** + * Number of logs emitted by this transaction + */ + log_count?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) + */ + log_data_bytes?: number; + /** + * Total number of topics across all logs + */ + log_topic_count?: number; + /** + * The name of the network + */ + meta_network_name?: string; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) + */ + receipt_bytes?: number; + /** + * 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 IntTransactionResourceGas = { /** * The block number containing the transaction @@ -10917,6 +11209,34 @@ export type ListFctExecutionGasUsedHourlyResponse = { next_page_token?: string; }; +/** + * Response for listing fct_execution_receipt_size_daily records + */ +export type ListFctExecutionReceiptSizeDailyResponse = { + /** + * The list of fct_execution_receipt_size_daily. + */ + fct_execution_receipt_size_daily?: 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 fct_execution_receipt_size_hourly records + */ +export type ListFctExecutionReceiptSizeHourlyResponse = { + /** + * The list of fct_execution_receipt_size_hourly. + */ + fct_execution_receipt_size_hourly?: 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 fct_execution_state_size_daily records */ @@ -11729,6 +12049,20 @@ export type ListIntBlockProposerCanonicalResponse = { next_page_token?: string; }; +/** + * Response for listing int_block_receipt_size records + */ +export type ListIntBlockReceiptSizeResponse = { + /** + * The list of int_block_receipt_size. + */ + int_block_receipt_size?: 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_block_resource_gas records */ @@ -12443,6 +12777,20 @@ export type ListIntTransactionOpcodeGasResponse = { next_page_token?: string; }; +/** + * Response for listing int_transaction_receipt_size records + */ +export type ListIntTransactionReceiptSizeResponse = { + /** + * The list of int_transaction_receipt_size. + */ + int_transaction_receipt_size?: 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_resource_gas records */ @@ -49153,6 +49501,1322 @@ export type FctExecutionGasUsedHourlyServiceGetResponses = { export type FctExecutionGasUsedHourlyServiceGetResponse = FctExecutionGasUsedHourlyServiceGetResponses[keyof FctExecutionGasUsedHourlyServiceGetResponses]; +export type FctExecutionReceiptSizeDailyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The start date of the day (filter: eq) + */ + day_start_date_eq?: string; + /** + * The start date of the day (filter: ne) + */ + day_start_date_ne?: string; + /** + * The start date of the day (filter: contains) + */ + day_start_date_contains?: string; + /** + * The start date of the day (filter: starts_with) + */ + day_start_date_starts_with?: string; + /** + * The start date of the day (filter: ends_with) + */ + day_start_date_ends_with?: string; + /** + * The start date of the day (filter: like) + */ + day_start_date_like?: string; + /** + * The start date of the day (filter: not_like) + */ + day_start_date_not_like?: string; + /** + * The start date of the day (filter: in_values) (comma-separated list) + */ + day_start_date_in_values?: string; + /** + * The start date of the day (filter: not_in_values) (comma-separated list) + */ + day_start_date_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; + /** + * Number of blocks in this day (filter: eq) + */ + block_count_eq?: number; + /** + * Number of blocks in this day (filter: ne) + */ + block_count_ne?: number; + /** + * Number of blocks in this day (filter: lt) + */ + block_count_lt?: number; + /** + * Number of blocks in this day (filter: lte) + */ + block_count_lte?: number; + /** + * Number of blocks in this day (filter: gt) + */ + block_count_gt?: number; + /** + * Number of blocks in this day (filter: gte) + */ + block_count_gte?: number; + /** + * Number of blocks in this day (filter: between_min) + */ + block_count_between_min?: number; + /** + * Number of blocks in this day (filter: between_max_value) + */ + block_count_between_max_value?: number; + /** + * Number of blocks in this day (filter: in_values) (comma-separated list) + */ + block_count_in_values?: string; + /** + * Number of blocks in this day (filter: not_in_values) (comma-separated list) + */ + block_count_not_in_values?: string; + /** + * Number of transactions in this day (filter: eq) + */ + transaction_count_eq?: number; + /** + * Number of transactions in this day (filter: ne) + */ + transaction_count_ne?: number; + /** + * Number of transactions in this day (filter: lt) + */ + transaction_count_lt?: number; + /** + * Number of transactions in this day (filter: lte) + */ + transaction_count_lte?: number; + /** + * Number of transactions in this day (filter: gt) + */ + transaction_count_gt?: number; + /** + * Number of transactions in this day (filter: gte) + */ + transaction_count_gte?: number; + /** + * Number of transactions in this day (filter: between_min) + */ + transaction_count_between_min?: number; + /** + * Number of transactions in this day (filter: between_max_value) + */ + transaction_count_between_max_value?: number; + /** + * Number of transactions in this day (filter: in_values) (comma-separated list) + */ + transaction_count_in_values?: string; + /** + * Number of transactions in this day (filter: not_in_values) (comma-separated list) + */ + transaction_count_not_in_values?: string; + /** + * Total receipt bytes across all blocks (filter: eq) + */ + total_receipt_bytes_eq?: number; + /** + * Total receipt bytes across all blocks (filter: ne) + */ + total_receipt_bytes_ne?: number; + /** + * Total receipt bytes across all blocks (filter: lt) + */ + total_receipt_bytes_lt?: number; + /** + * Total receipt bytes across all blocks (filter: lte) + */ + total_receipt_bytes_lte?: number; + /** + * Total receipt bytes across all blocks (filter: gt) + */ + total_receipt_bytes_gt?: number; + /** + * Total receipt bytes across all blocks (filter: gte) + */ + total_receipt_bytes_gte?: number; + /** + * Total receipt bytes across all blocks (filter: between_min) + */ + total_receipt_bytes_between_min?: number; + /** + * Total receipt bytes across all blocks (filter: between_max_value) + */ + total_receipt_bytes_between_max_value?: number; + /** + * Total receipt bytes across all blocks (filter: in_values) (comma-separated list) + */ + total_receipt_bytes_in_values?: string; + /** + * Total receipt bytes across all blocks (filter: not_in_values) (comma-separated list) + */ + total_receipt_bytes_not_in_values?: string; + /** + * Filter avg_receipt_bytes_per_block using value + */ + avg_receipt_bytes_per_block_value?: number; + /** + * Minimum total receipt bytes in a single block (filter: eq) + */ + min_receipt_bytes_per_block_eq?: number; + /** + * Minimum total receipt bytes in a single block (filter: ne) + */ + min_receipt_bytes_per_block_ne?: number; + /** + * Minimum total receipt bytes in a single block (filter: lt) + */ + min_receipt_bytes_per_block_lt?: number; + /** + * Minimum total receipt bytes in a single block (filter: lte) + */ + min_receipt_bytes_per_block_lte?: number; + /** + * Minimum total receipt bytes in a single block (filter: gt) + */ + min_receipt_bytes_per_block_gt?: number; + /** + * Minimum total receipt bytes in a single block (filter: gte) + */ + min_receipt_bytes_per_block_gte?: number; + /** + * Minimum total receipt bytes in a single block (filter: between_min) + */ + min_receipt_bytes_per_block_between_min?: number; + /** + * Minimum total receipt bytes in a single block (filter: between_max_value) + */ + min_receipt_bytes_per_block_between_max_value?: number; + /** + * Minimum total receipt bytes in a single block (filter: in_values) (comma-separated list) + */ + min_receipt_bytes_per_block_in_values?: string; + /** + * Minimum total receipt bytes in a single block (filter: not_in_values) (comma-separated list) + */ + min_receipt_bytes_per_block_not_in_values?: string; + /** + * Maximum total receipt bytes in a single block (filter: eq) + */ + max_receipt_bytes_per_block_eq?: number; + /** + * Maximum total receipt bytes in a single block (filter: ne) + */ + max_receipt_bytes_per_block_ne?: number; + /** + * Maximum total receipt bytes in a single block (filter: lt) + */ + max_receipt_bytes_per_block_lt?: number; + /** + * Maximum total receipt bytes in a single block (filter: lte) + */ + max_receipt_bytes_per_block_lte?: number; + /** + * Maximum total receipt bytes in a single block (filter: gt) + */ + max_receipt_bytes_per_block_gt?: number; + /** + * Maximum total receipt bytes in a single block (filter: gte) + */ + max_receipt_bytes_per_block_gte?: number; + /** + * Maximum total receipt bytes in a single block (filter: between_min) + */ + max_receipt_bytes_per_block_between_min?: number; + /** + * Maximum total receipt bytes in a single block (filter: between_max_value) + */ + max_receipt_bytes_per_block_between_max_value?: number; + /** + * Maximum total receipt bytes in a single block (filter: in_values) (comma-separated list) + */ + max_receipt_bytes_per_block_in_values?: string; + /** + * Maximum total receipt bytes in a single block (filter: not_in_values) (comma-separated list) + */ + max_receipt_bytes_per_block_not_in_values?: string; + /** + * 5th percentile of total receipt bytes per block (filter: eq) + */ + p05_receipt_bytes_per_block_eq?: number; + /** + * 5th percentile of total receipt bytes per block (filter: ne) + */ + p05_receipt_bytes_per_block_ne?: number; + /** + * 5th percentile of total receipt bytes per block (filter: lt) + */ + p05_receipt_bytes_per_block_lt?: number; + /** + * 5th percentile of total receipt bytes per block (filter: lte) + */ + p05_receipt_bytes_per_block_lte?: number; + /** + * 5th percentile of total receipt bytes per block (filter: gt) + */ + p05_receipt_bytes_per_block_gt?: number; + /** + * 5th percentile of total receipt bytes per block (filter: gte) + */ + p05_receipt_bytes_per_block_gte?: number; + /** + * 5th percentile of total receipt bytes per block (filter: between_min) + */ + p05_receipt_bytes_per_block_between_min?: number; + /** + * 5th percentile of total receipt bytes per block (filter: between_max_value) + */ + p05_receipt_bytes_per_block_between_max_value?: number; + /** + * 5th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p05_receipt_bytes_per_block_in_values?: string; + /** + * 5th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p05_receipt_bytes_per_block_not_in_values?: string; + /** + * 50th percentile of total receipt bytes per block (filter: eq) + */ + p50_receipt_bytes_per_block_eq?: number; + /** + * 50th percentile of total receipt bytes per block (filter: ne) + */ + p50_receipt_bytes_per_block_ne?: number; + /** + * 50th percentile of total receipt bytes per block (filter: lt) + */ + p50_receipt_bytes_per_block_lt?: number; + /** + * 50th percentile of total receipt bytes per block (filter: lte) + */ + p50_receipt_bytes_per_block_lte?: number; + /** + * 50th percentile of total receipt bytes per block (filter: gt) + */ + p50_receipt_bytes_per_block_gt?: number; + /** + * 50th percentile of total receipt bytes per block (filter: gte) + */ + p50_receipt_bytes_per_block_gte?: number; + /** + * 50th percentile of total receipt bytes per block (filter: between_min) + */ + p50_receipt_bytes_per_block_between_min?: number; + /** + * 50th percentile of total receipt bytes per block (filter: between_max_value) + */ + p50_receipt_bytes_per_block_between_max_value?: number; + /** + * 50th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p50_receipt_bytes_per_block_in_values?: string; + /** + * 50th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p50_receipt_bytes_per_block_not_in_values?: string; + /** + * 95th percentile of total receipt bytes per block (filter: eq) + */ + p95_receipt_bytes_per_block_eq?: number; + /** + * 95th percentile of total receipt bytes per block (filter: ne) + */ + p95_receipt_bytes_per_block_ne?: number; + /** + * 95th percentile of total receipt bytes per block (filter: lt) + */ + p95_receipt_bytes_per_block_lt?: number; + /** + * 95th percentile of total receipt bytes per block (filter: lte) + */ + p95_receipt_bytes_per_block_lte?: number; + /** + * 95th percentile of total receipt bytes per block (filter: gt) + */ + p95_receipt_bytes_per_block_gt?: number; + /** + * 95th percentile of total receipt bytes per block (filter: gte) + */ + p95_receipt_bytes_per_block_gte?: number; + /** + * 95th percentile of total receipt bytes per block (filter: between_min) + */ + p95_receipt_bytes_per_block_between_min?: number; + /** + * 95th percentile of total receipt bytes per block (filter: between_max_value) + */ + p95_receipt_bytes_per_block_between_max_value?: number; + /** + * 95th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p95_receipt_bytes_per_block_in_values?: string; + /** + * 95th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p95_receipt_bytes_per_block_not_in_values?: string; + /** + * Filter stddev_receipt_bytes_per_block using value + */ + stddev_receipt_bytes_per_block_value?: number; + /** + * Filter upper_band_receipt_bytes_per_block using value + */ + upper_band_receipt_bytes_per_block_value?: number; + /** + * Filter lower_band_receipt_bytes_per_block using value + */ + lower_band_receipt_bytes_per_block_value?: number; + /** + * Filter moving_avg_receipt_bytes_per_block using value + */ + moving_avg_receipt_bytes_per_block_value?: number; + /** + * Filter avg_receipt_bytes_per_transaction using value + */ + avg_receipt_bytes_per_transaction_value?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: eq) + */ + p50_receipt_bytes_per_transaction_eq?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: ne) + */ + p50_receipt_bytes_per_transaction_ne?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lt) + */ + p50_receipt_bytes_per_transaction_lt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lte) + */ + p50_receipt_bytes_per_transaction_lte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gt) + */ + p50_receipt_bytes_per_transaction_gt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gte) + */ + p50_receipt_bytes_per_transaction_gte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_min) + */ + p50_receipt_bytes_per_transaction_between_min?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p50_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_in_values?: string; + /** + * 50th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_not_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: eq) + */ + p95_receipt_bytes_per_transaction_eq?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: ne) + */ + p95_receipt_bytes_per_transaction_ne?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lt) + */ + p95_receipt_bytes_per_transaction_lt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lte) + */ + p95_receipt_bytes_per_transaction_lte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gt) + */ + p95_receipt_bytes_per_transaction_gt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gte) + */ + p95_receipt_bytes_per_transaction_gte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_min) + */ + p95_receipt_bytes_per_transaction_between_min?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p95_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_not_in_values?: string; + /** + * Total logs emitted across all transactions (filter: eq) + */ + total_log_count_eq?: number; + /** + * Total logs emitted across all transactions (filter: ne) + */ + total_log_count_ne?: number; + /** + * Total logs emitted across all transactions (filter: lt) + */ + total_log_count_lt?: number; + /** + * Total logs emitted across all transactions (filter: lte) + */ + total_log_count_lte?: number; + /** + * Total logs emitted across all transactions (filter: gt) + */ + total_log_count_gt?: number; + /** + * Total logs emitted across all transactions (filter: gte) + */ + total_log_count_gte?: number; + /** + * Total logs emitted across all transactions (filter: between_min) + */ + total_log_count_between_min?: number; + /** + * Total logs emitted across all transactions (filter: between_max_value) + */ + total_log_count_between_max_value?: number; + /** + * Total logs emitted across all transactions (filter: in_values) (comma-separated list) + */ + total_log_count_in_values?: string; + /** + * Total logs emitted across all transactions (filter: not_in_values) (comma-separated list) + */ + total_log_count_not_in_values?: string; + /** + * Filter avg_log_count_per_transaction using value + */ + avg_log_count_per_transaction_value?: number; + /** + * Running total of receipt bytes since genesis (filter: eq) + */ + cumulative_receipt_bytes_eq?: number; + /** + * Running total of receipt bytes since genesis (filter: ne) + */ + cumulative_receipt_bytes_ne?: number; + /** + * Running total of receipt bytes since genesis (filter: lt) + */ + cumulative_receipt_bytes_lt?: number; + /** + * Running total of receipt bytes since genesis (filter: lte) + */ + cumulative_receipt_bytes_lte?: number; + /** + * Running total of receipt bytes since genesis (filter: gt) + */ + cumulative_receipt_bytes_gt?: number; + /** + * Running total of receipt bytes since genesis (filter: gte) + */ + cumulative_receipt_bytes_gte?: number; + /** + * Running total of receipt bytes since genesis (filter: between_min) + */ + cumulative_receipt_bytes_between_min?: number; + /** + * Running total of receipt bytes since genesis (filter: between_max_value) + */ + cumulative_receipt_bytes_between_max_value?: number; + /** + * Running total of receipt bytes since genesis (filter: in_values) (comma-separated list) + */ + cumulative_receipt_bytes_in_values?: string; + /** + * Running total of receipt bytes since genesis (filter: not_in_values) (comma-separated list) + */ + cumulative_receipt_bytes_not_in_values?: string; + /** + * The maximum number of fct_execution_receipt_size_daily 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 `ListFctExecutionReceiptSizeDaily` 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/fct_execution_receipt_size_daily'; +}; + +export type FctExecutionReceiptSizeDailyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctExecutionReceiptSizeDailyServiceListError = + FctExecutionReceiptSizeDailyServiceListErrors[keyof FctExecutionReceiptSizeDailyServiceListErrors]; + +export type FctExecutionReceiptSizeDailyServiceListResponses = { + /** + * OK + */ + 200: ListFctExecutionReceiptSizeDailyResponse; +}; + +export type FctExecutionReceiptSizeDailyServiceListResponse = + FctExecutionReceiptSizeDailyServiceListResponses[keyof FctExecutionReceiptSizeDailyServiceListResponses]; + +export type FctExecutionReceiptSizeDailyServiceGetData = { + body?: never; + path: { + /** + * The start date of the day + */ + day_start_date: string; + }; + query?: never; + url: '/api/v1/fct_execution_receipt_size_daily/{day_start_date}'; +}; + +export type FctExecutionReceiptSizeDailyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctExecutionReceiptSizeDailyServiceGetError = + FctExecutionReceiptSizeDailyServiceGetErrors[keyof FctExecutionReceiptSizeDailyServiceGetErrors]; + +export type FctExecutionReceiptSizeDailyServiceGetResponses = { + /** + * OK + */ + 200: GetFctExecutionReceiptSizeDailyResponse; +}; + +export type FctExecutionReceiptSizeDailyServiceGetResponse = + FctExecutionReceiptSizeDailyServiceGetResponses[keyof FctExecutionReceiptSizeDailyServiceGetResponses]; + +export type FctExecutionReceiptSizeHourlyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The start time of the hour (filter: eq) + */ + hour_start_date_time_eq?: number; + /** + * The start time of the hour (filter: ne) + */ + hour_start_date_time_ne?: number; + /** + * The start time of the hour (filter: lt) + */ + hour_start_date_time_lt?: number; + /** + * The start time of the hour (filter: lte) + */ + hour_start_date_time_lte?: number; + /** + * The start time of the hour (filter: gt) + */ + hour_start_date_time_gt?: number; + /** + * The start time of the hour (filter: gte) + */ + hour_start_date_time_gte?: number; + /** + * The start time of the hour (filter: between_min) + */ + hour_start_date_time_between_min?: number; + /** + * The start time of the hour (filter: between_max_value) + */ + hour_start_date_time_between_max_value?: number; + /** + * The start time of the hour (filter: in_values) (comma-separated list) + */ + hour_start_date_time_in_values?: string; + /** + * The start time of the hour (filter: not_in_values) (comma-separated list) + */ + hour_start_date_time_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; + /** + * Number of blocks in this hour (filter: eq) + */ + block_count_eq?: number; + /** + * Number of blocks in this hour (filter: ne) + */ + block_count_ne?: number; + /** + * Number of blocks in this hour (filter: lt) + */ + block_count_lt?: number; + /** + * Number of blocks in this hour (filter: lte) + */ + block_count_lte?: number; + /** + * Number of blocks in this hour (filter: gt) + */ + block_count_gt?: number; + /** + * Number of blocks in this hour (filter: gte) + */ + block_count_gte?: number; + /** + * Number of blocks in this hour (filter: between_min) + */ + block_count_between_min?: number; + /** + * Number of blocks in this hour (filter: between_max_value) + */ + block_count_between_max_value?: number; + /** + * Number of blocks in this hour (filter: in_values) (comma-separated list) + */ + block_count_in_values?: string; + /** + * Number of blocks in this hour (filter: not_in_values) (comma-separated list) + */ + block_count_not_in_values?: string; + /** + * Number of transactions in this hour (filter: eq) + */ + transaction_count_eq?: number; + /** + * Number of transactions in this hour (filter: ne) + */ + transaction_count_ne?: number; + /** + * Number of transactions in this hour (filter: lt) + */ + transaction_count_lt?: number; + /** + * Number of transactions in this hour (filter: lte) + */ + transaction_count_lte?: number; + /** + * Number of transactions in this hour (filter: gt) + */ + transaction_count_gt?: number; + /** + * Number of transactions in this hour (filter: gte) + */ + transaction_count_gte?: number; + /** + * Number of transactions in this hour (filter: between_min) + */ + transaction_count_between_min?: number; + /** + * Number of transactions in this hour (filter: between_max_value) + */ + transaction_count_between_max_value?: number; + /** + * Number of transactions in this hour (filter: in_values) (comma-separated list) + */ + transaction_count_in_values?: string; + /** + * Number of transactions in this hour (filter: not_in_values) (comma-separated list) + */ + transaction_count_not_in_values?: string; + /** + * Total receipt bytes across all blocks (filter: eq) + */ + total_receipt_bytes_eq?: number; + /** + * Total receipt bytes across all blocks (filter: ne) + */ + total_receipt_bytes_ne?: number; + /** + * Total receipt bytes across all blocks (filter: lt) + */ + total_receipt_bytes_lt?: number; + /** + * Total receipt bytes across all blocks (filter: lte) + */ + total_receipt_bytes_lte?: number; + /** + * Total receipt bytes across all blocks (filter: gt) + */ + total_receipt_bytes_gt?: number; + /** + * Total receipt bytes across all blocks (filter: gte) + */ + total_receipt_bytes_gte?: number; + /** + * Total receipt bytes across all blocks (filter: between_min) + */ + total_receipt_bytes_between_min?: number; + /** + * Total receipt bytes across all blocks (filter: between_max_value) + */ + total_receipt_bytes_between_max_value?: number; + /** + * Total receipt bytes across all blocks (filter: in_values) (comma-separated list) + */ + total_receipt_bytes_in_values?: string; + /** + * Total receipt bytes across all blocks (filter: not_in_values) (comma-separated list) + */ + total_receipt_bytes_not_in_values?: string; + /** + * Filter avg_receipt_bytes_per_block using value + */ + avg_receipt_bytes_per_block_value?: number; + /** + * Minimum total receipt bytes in a single block (filter: eq) + */ + min_receipt_bytes_per_block_eq?: number; + /** + * Minimum total receipt bytes in a single block (filter: ne) + */ + min_receipt_bytes_per_block_ne?: number; + /** + * Minimum total receipt bytes in a single block (filter: lt) + */ + min_receipt_bytes_per_block_lt?: number; + /** + * Minimum total receipt bytes in a single block (filter: lte) + */ + min_receipt_bytes_per_block_lte?: number; + /** + * Minimum total receipt bytes in a single block (filter: gt) + */ + min_receipt_bytes_per_block_gt?: number; + /** + * Minimum total receipt bytes in a single block (filter: gte) + */ + min_receipt_bytes_per_block_gte?: number; + /** + * Minimum total receipt bytes in a single block (filter: between_min) + */ + min_receipt_bytes_per_block_between_min?: number; + /** + * Minimum total receipt bytes in a single block (filter: between_max_value) + */ + min_receipt_bytes_per_block_between_max_value?: number; + /** + * Minimum total receipt bytes in a single block (filter: in_values) (comma-separated list) + */ + min_receipt_bytes_per_block_in_values?: string; + /** + * Minimum total receipt bytes in a single block (filter: not_in_values) (comma-separated list) + */ + min_receipt_bytes_per_block_not_in_values?: string; + /** + * Maximum total receipt bytes in a single block (filter: eq) + */ + max_receipt_bytes_per_block_eq?: number; + /** + * Maximum total receipt bytes in a single block (filter: ne) + */ + max_receipt_bytes_per_block_ne?: number; + /** + * Maximum total receipt bytes in a single block (filter: lt) + */ + max_receipt_bytes_per_block_lt?: number; + /** + * Maximum total receipt bytes in a single block (filter: lte) + */ + max_receipt_bytes_per_block_lte?: number; + /** + * Maximum total receipt bytes in a single block (filter: gt) + */ + max_receipt_bytes_per_block_gt?: number; + /** + * Maximum total receipt bytes in a single block (filter: gte) + */ + max_receipt_bytes_per_block_gte?: number; + /** + * Maximum total receipt bytes in a single block (filter: between_min) + */ + max_receipt_bytes_per_block_between_min?: number; + /** + * Maximum total receipt bytes in a single block (filter: between_max_value) + */ + max_receipt_bytes_per_block_between_max_value?: number; + /** + * Maximum total receipt bytes in a single block (filter: in_values) (comma-separated list) + */ + max_receipt_bytes_per_block_in_values?: string; + /** + * Maximum total receipt bytes in a single block (filter: not_in_values) (comma-separated list) + */ + max_receipt_bytes_per_block_not_in_values?: string; + /** + * 5th percentile of total receipt bytes per block (filter: eq) + */ + p05_receipt_bytes_per_block_eq?: number; + /** + * 5th percentile of total receipt bytes per block (filter: ne) + */ + p05_receipt_bytes_per_block_ne?: number; + /** + * 5th percentile of total receipt bytes per block (filter: lt) + */ + p05_receipt_bytes_per_block_lt?: number; + /** + * 5th percentile of total receipt bytes per block (filter: lte) + */ + p05_receipt_bytes_per_block_lte?: number; + /** + * 5th percentile of total receipt bytes per block (filter: gt) + */ + p05_receipt_bytes_per_block_gt?: number; + /** + * 5th percentile of total receipt bytes per block (filter: gte) + */ + p05_receipt_bytes_per_block_gte?: number; + /** + * 5th percentile of total receipt bytes per block (filter: between_min) + */ + p05_receipt_bytes_per_block_between_min?: number; + /** + * 5th percentile of total receipt bytes per block (filter: between_max_value) + */ + p05_receipt_bytes_per_block_between_max_value?: number; + /** + * 5th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p05_receipt_bytes_per_block_in_values?: string; + /** + * 5th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p05_receipt_bytes_per_block_not_in_values?: string; + /** + * 50th percentile of total receipt bytes per block (filter: eq) + */ + p50_receipt_bytes_per_block_eq?: number; + /** + * 50th percentile of total receipt bytes per block (filter: ne) + */ + p50_receipt_bytes_per_block_ne?: number; + /** + * 50th percentile of total receipt bytes per block (filter: lt) + */ + p50_receipt_bytes_per_block_lt?: number; + /** + * 50th percentile of total receipt bytes per block (filter: lte) + */ + p50_receipt_bytes_per_block_lte?: number; + /** + * 50th percentile of total receipt bytes per block (filter: gt) + */ + p50_receipt_bytes_per_block_gt?: number; + /** + * 50th percentile of total receipt bytes per block (filter: gte) + */ + p50_receipt_bytes_per_block_gte?: number; + /** + * 50th percentile of total receipt bytes per block (filter: between_min) + */ + p50_receipt_bytes_per_block_between_min?: number; + /** + * 50th percentile of total receipt bytes per block (filter: between_max_value) + */ + p50_receipt_bytes_per_block_between_max_value?: number; + /** + * 50th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p50_receipt_bytes_per_block_in_values?: string; + /** + * 50th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p50_receipt_bytes_per_block_not_in_values?: string; + /** + * 95th percentile of total receipt bytes per block (filter: eq) + */ + p95_receipt_bytes_per_block_eq?: number; + /** + * 95th percentile of total receipt bytes per block (filter: ne) + */ + p95_receipt_bytes_per_block_ne?: number; + /** + * 95th percentile of total receipt bytes per block (filter: lt) + */ + p95_receipt_bytes_per_block_lt?: number; + /** + * 95th percentile of total receipt bytes per block (filter: lte) + */ + p95_receipt_bytes_per_block_lte?: number; + /** + * 95th percentile of total receipt bytes per block (filter: gt) + */ + p95_receipt_bytes_per_block_gt?: number; + /** + * 95th percentile of total receipt bytes per block (filter: gte) + */ + p95_receipt_bytes_per_block_gte?: number; + /** + * 95th percentile of total receipt bytes per block (filter: between_min) + */ + p95_receipt_bytes_per_block_between_min?: number; + /** + * 95th percentile of total receipt bytes per block (filter: between_max_value) + */ + p95_receipt_bytes_per_block_between_max_value?: number; + /** + * 95th percentile of total receipt bytes per block (filter: in_values) (comma-separated list) + */ + p95_receipt_bytes_per_block_in_values?: string; + /** + * 95th percentile of total receipt bytes per block (filter: not_in_values) (comma-separated list) + */ + p95_receipt_bytes_per_block_not_in_values?: string; + /** + * Filter stddev_receipt_bytes_per_block using value + */ + stddev_receipt_bytes_per_block_value?: number; + /** + * Filter upper_band_receipt_bytes_per_block using value + */ + upper_band_receipt_bytes_per_block_value?: number; + /** + * Filter lower_band_receipt_bytes_per_block using value + */ + lower_band_receipt_bytes_per_block_value?: number; + /** + * Filter moving_avg_receipt_bytes_per_block using value + */ + moving_avg_receipt_bytes_per_block_value?: number; + /** + * Filter avg_receipt_bytes_per_transaction using value + */ + avg_receipt_bytes_per_transaction_value?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: eq) + */ + p50_receipt_bytes_per_transaction_eq?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: ne) + */ + p50_receipt_bytes_per_transaction_ne?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lt) + */ + p50_receipt_bytes_per_transaction_lt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lte) + */ + p50_receipt_bytes_per_transaction_lte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gt) + */ + p50_receipt_bytes_per_transaction_gt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gte) + */ + p50_receipt_bytes_per_transaction_gte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_min) + */ + p50_receipt_bytes_per_transaction_between_min?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p50_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_in_values?: string; + /** + * 50th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_not_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: eq) + */ + p95_receipt_bytes_per_transaction_eq?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: ne) + */ + p95_receipt_bytes_per_transaction_ne?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lt) + */ + p95_receipt_bytes_per_transaction_lt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lte) + */ + p95_receipt_bytes_per_transaction_lte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gt) + */ + p95_receipt_bytes_per_transaction_gt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gte) + */ + p95_receipt_bytes_per_transaction_gte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_min) + */ + p95_receipt_bytes_per_transaction_between_min?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p95_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_not_in_values?: string; + /** + * Total logs emitted across all transactions (filter: eq) + */ + total_log_count_eq?: number; + /** + * Total logs emitted across all transactions (filter: ne) + */ + total_log_count_ne?: number; + /** + * Total logs emitted across all transactions (filter: lt) + */ + total_log_count_lt?: number; + /** + * Total logs emitted across all transactions (filter: lte) + */ + total_log_count_lte?: number; + /** + * Total logs emitted across all transactions (filter: gt) + */ + total_log_count_gt?: number; + /** + * Total logs emitted across all transactions (filter: gte) + */ + total_log_count_gte?: number; + /** + * Total logs emitted across all transactions (filter: between_min) + */ + total_log_count_between_min?: number; + /** + * Total logs emitted across all transactions (filter: between_max_value) + */ + total_log_count_between_max_value?: number; + /** + * Total logs emitted across all transactions (filter: in_values) (comma-separated list) + */ + total_log_count_in_values?: string; + /** + * Total logs emitted across all transactions (filter: not_in_values) (comma-separated list) + */ + total_log_count_not_in_values?: string; + /** + * Filter avg_log_count_per_transaction using value + */ + avg_log_count_per_transaction_value?: number; + /** + * Running total of receipt bytes since genesis (filter: eq) + */ + cumulative_receipt_bytes_eq?: number; + /** + * Running total of receipt bytes since genesis (filter: ne) + */ + cumulative_receipt_bytes_ne?: number; + /** + * Running total of receipt bytes since genesis (filter: lt) + */ + cumulative_receipt_bytes_lt?: number; + /** + * Running total of receipt bytes since genesis (filter: lte) + */ + cumulative_receipt_bytes_lte?: number; + /** + * Running total of receipt bytes since genesis (filter: gt) + */ + cumulative_receipt_bytes_gt?: number; + /** + * Running total of receipt bytes since genesis (filter: gte) + */ + cumulative_receipt_bytes_gte?: number; + /** + * Running total of receipt bytes since genesis (filter: between_min) + */ + cumulative_receipt_bytes_between_min?: number; + /** + * Running total of receipt bytes since genesis (filter: between_max_value) + */ + cumulative_receipt_bytes_between_max_value?: number; + /** + * Running total of receipt bytes since genesis (filter: in_values) (comma-separated list) + */ + cumulative_receipt_bytes_in_values?: string; + /** + * Running total of receipt bytes since genesis (filter: not_in_values) (comma-separated list) + */ + cumulative_receipt_bytes_not_in_values?: string; + /** + * The maximum number of fct_execution_receipt_size_hourly 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 `ListFctExecutionReceiptSizeHourly` 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/fct_execution_receipt_size_hourly'; +}; + +export type FctExecutionReceiptSizeHourlyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctExecutionReceiptSizeHourlyServiceListError = + FctExecutionReceiptSizeHourlyServiceListErrors[keyof FctExecutionReceiptSizeHourlyServiceListErrors]; + +export type FctExecutionReceiptSizeHourlyServiceListResponses = { + /** + * OK + */ + 200: ListFctExecutionReceiptSizeHourlyResponse; +}; + +export type FctExecutionReceiptSizeHourlyServiceListResponse = + FctExecutionReceiptSizeHourlyServiceListResponses[keyof FctExecutionReceiptSizeHourlyServiceListResponses]; + +export type FctExecutionReceiptSizeHourlyServiceGetData = { + body?: never; + path: { + /** + * The start time of the hour + */ + hour_start_date_time: number; + }; + query?: never; + url: '/api/v1/fct_execution_receipt_size_hourly/{hour_start_date_time}'; +}; + +export type FctExecutionReceiptSizeHourlyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctExecutionReceiptSizeHourlyServiceGetError = + FctExecutionReceiptSizeHourlyServiceGetErrors[keyof FctExecutionReceiptSizeHourlyServiceGetErrors]; + +export type FctExecutionReceiptSizeHourlyServiceGetResponses = { + /** + * OK + */ + 200: GetFctExecutionReceiptSizeHourlyResponse; +}; + +export type FctExecutionReceiptSizeHourlyServiceGetResponse = + FctExecutionReceiptSizeHourlyServiceGetResponses[keyof FctExecutionReceiptSizeHourlyServiceGetResponses]; + export type FctExecutionStateSizeDailyServiceListData = { body?: never; path?: never; @@ -72847,6 +74511,518 @@ export type IntBlockProposerCanonicalServiceGetResponses = { export type IntBlockProposerCanonicalServiceGetResponse = IntBlockProposerCanonicalServiceGetResponses[keyof IntBlockProposerCanonicalServiceGetResponses]; +export type IntBlockReceiptSizeServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The block number (filter: eq) + */ + block_number_eq?: number; + /** + * The block number (filter: ne) + */ + block_number_ne?: number; + /** + * The block number (filter: lt) + */ + block_number_lt?: number; + /** + * The block number (filter: lte) + */ + block_number_lte?: number; + /** + * The block number (filter: gt) + */ + block_number_gt?: number; + /** + * The block number (filter: gte) + */ + block_number_gte?: number; + /** + * The block number (filter: between_min) + */ + block_number_between_min?: number; + /** + * The block number (filter: between_max_value) + */ + block_number_between_max_value?: number; + /** + * The block number (filter: in_values) (comma-separated list) + */ + block_number_in_values?: string; + /** + * The block number (filter: not_in_values) (comma-separated list) + */ + block_number_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; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: eq) + */ + receipt_bytes_eq?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: ne) + */ + receipt_bytes_ne?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: lt) + */ + receipt_bytes_lt?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: lte) + */ + receipt_bytes_lte?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: gt) + */ + receipt_bytes_gt?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: gte) + */ + receipt_bytes_gte?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: between_min) + */ + receipt_bytes_between_min?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: between_max_value) + */ + receipt_bytes_between_max_value?: number; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: in_values) (comma-separated list) + */ + receipt_bytes_in_values?: string; + /** + * Total RLP-encoded receipt bytes across all transactions in the block (filter: not_in_values) (comma-separated list) + */ + receipt_bytes_not_in_values?: string; + /** + * Number of transactions in the block (filter: eq) + */ + transaction_count_eq?: number; + /** + * Number of transactions in the block (filter: ne) + */ + transaction_count_ne?: number; + /** + * Number of transactions in the block (filter: lt) + */ + transaction_count_lt?: number; + /** + * Number of transactions in the block (filter: lte) + */ + transaction_count_lte?: number; + /** + * Number of transactions in the block (filter: gt) + */ + transaction_count_gt?: number; + /** + * Number of transactions in the block (filter: gte) + */ + transaction_count_gte?: number; + /** + * Number of transactions in the block (filter: between_min) + */ + transaction_count_between_min?: number; + /** + * Number of transactions in the block (filter: between_max_value) + */ + transaction_count_between_max_value?: number; + /** + * Number of transactions in the block (filter: in_values) (comma-separated list) + */ + transaction_count_in_values?: string; + /** + * Number of transactions in the block (filter: not_in_values) (comma-separated list) + */ + transaction_count_not_in_values?: string; + /** + * Total logs emitted across all transactions in the block (filter: eq) + */ + log_count_eq?: number; + /** + * Total logs emitted across all transactions in the block (filter: ne) + */ + log_count_ne?: number; + /** + * Total logs emitted across all transactions in the block (filter: lt) + */ + log_count_lt?: number; + /** + * Total logs emitted across all transactions in the block (filter: lte) + */ + log_count_lte?: number; + /** + * Total logs emitted across all transactions in the block (filter: gt) + */ + log_count_gt?: number; + /** + * Total logs emitted across all transactions in the block (filter: gte) + */ + log_count_gte?: number; + /** + * Total logs emitted across all transactions in the block (filter: between_min) + */ + log_count_between_min?: number; + /** + * Total logs emitted across all transactions in the block (filter: between_max_value) + */ + log_count_between_max_value?: number; + /** + * Total logs emitted across all transactions in the block (filter: in_values) (comma-separated list) + */ + log_count_in_values?: string; + /** + * Total logs emitted across all transactions in the block (filter: not_in_values) (comma-separated list) + */ + log_count_not_in_values?: string; + /** + * Total raw bytes of log data fields across all transactions (filter: eq) + */ + log_data_bytes_eq?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: ne) + */ + log_data_bytes_ne?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: lt) + */ + log_data_bytes_lt?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: lte) + */ + log_data_bytes_lte?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: gt) + */ + log_data_bytes_gt?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: gte) + */ + log_data_bytes_gte?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: between_min) + */ + log_data_bytes_between_min?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: between_max_value) + */ + log_data_bytes_between_max_value?: number; + /** + * Total raw bytes of log data fields across all transactions (filter: in_values) (comma-separated list) + */ + log_data_bytes_in_values?: string; + /** + * Total raw bytes of log data fields across all transactions (filter: not_in_values) (comma-separated list) + */ + log_data_bytes_not_in_values?: string; + /** + * Total number of topics across all logs in the block (filter: eq) + */ + log_topic_count_eq?: number; + /** + * Total number of topics across all logs in the block (filter: ne) + */ + log_topic_count_ne?: number; + /** + * Total number of topics across all logs in the block (filter: lt) + */ + log_topic_count_lt?: number; + /** + * Total number of topics across all logs in the block (filter: lte) + */ + log_topic_count_lte?: number; + /** + * Total number of topics across all logs in the block (filter: gt) + */ + log_topic_count_gt?: number; + /** + * Total number of topics across all logs in the block (filter: gte) + */ + log_topic_count_gte?: number; + /** + * Total number of topics across all logs in the block (filter: between_min) + */ + log_topic_count_between_min?: number; + /** + * Total number of topics across all logs in the block (filter: between_max_value) + */ + log_topic_count_between_max_value?: number; + /** + * Total number of topics across all logs in the block (filter: in_values) (comma-separated list) + */ + log_topic_count_in_values?: string; + /** + * Total number of topics across all logs in the block (filter: not_in_values) (comma-separated list) + */ + log_topic_count_not_in_values?: string; + /** + * Filter avg_receipt_bytes_per_transaction using value + */ + avg_receipt_bytes_per_transaction_value?: number; + /** + * Largest single transaction receipt in this block (filter: eq) + */ + max_receipt_bytes_per_transaction_eq?: number; + /** + * Largest single transaction receipt in this block (filter: ne) + */ + max_receipt_bytes_per_transaction_ne?: number; + /** + * Largest single transaction receipt in this block (filter: lt) + */ + max_receipt_bytes_per_transaction_lt?: number; + /** + * Largest single transaction receipt in this block (filter: lte) + */ + max_receipt_bytes_per_transaction_lte?: number; + /** + * Largest single transaction receipt in this block (filter: gt) + */ + max_receipt_bytes_per_transaction_gt?: number; + /** + * Largest single transaction receipt in this block (filter: gte) + */ + max_receipt_bytes_per_transaction_gte?: number; + /** + * Largest single transaction receipt in this block (filter: between_min) + */ + max_receipt_bytes_per_transaction_between_min?: number; + /** + * Largest single transaction receipt in this block (filter: between_max_value) + */ + max_receipt_bytes_per_transaction_between_max_value?: number; + /** + * Largest single transaction receipt in this block (filter: in_values) (comma-separated list) + */ + max_receipt_bytes_per_transaction_in_values?: string; + /** + * Largest single transaction receipt in this block (filter: not_in_values) (comma-separated list) + */ + max_receipt_bytes_per_transaction_not_in_values?: string; + /** + * 50th percentile of receipt bytes per transaction (filter: eq) + */ + p50_receipt_bytes_per_transaction_eq?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: ne) + */ + p50_receipt_bytes_per_transaction_ne?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lt) + */ + p50_receipt_bytes_per_transaction_lt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: lte) + */ + p50_receipt_bytes_per_transaction_lte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gt) + */ + p50_receipt_bytes_per_transaction_gt?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: gte) + */ + p50_receipt_bytes_per_transaction_gte?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_min) + */ + p50_receipt_bytes_per_transaction_between_min?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p50_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 50th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_in_values?: string; + /** + * 50th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p50_receipt_bytes_per_transaction_not_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: eq) + */ + p95_receipt_bytes_per_transaction_eq?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: ne) + */ + p95_receipt_bytes_per_transaction_ne?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lt) + */ + p95_receipt_bytes_per_transaction_lt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: lte) + */ + p95_receipt_bytes_per_transaction_lte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gt) + */ + p95_receipt_bytes_per_transaction_gt?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: gte) + */ + p95_receipt_bytes_per_transaction_gte?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_min) + */ + p95_receipt_bytes_per_transaction_between_min?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: between_max_value) + */ + p95_receipt_bytes_per_transaction_between_max_value?: number; + /** + * 95th percentile of receipt bytes per transaction (filter: in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_in_values?: string; + /** + * 95th percentile of receipt bytes per transaction (filter: not_in_values) (comma-separated list) + */ + p95_receipt_bytes_per_transaction_not_in_values?: string; + /** + * The maximum number of int_block_receipt_size 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 `ListIntBlockReceiptSize` 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_receipt_size'; +}; + +export type IntBlockReceiptSizeServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntBlockReceiptSizeServiceListError = + IntBlockReceiptSizeServiceListErrors[keyof IntBlockReceiptSizeServiceListErrors]; + +export type IntBlockReceiptSizeServiceListResponses = { + /** + * OK + */ + 200: ListIntBlockReceiptSizeResponse; +}; + +export type IntBlockReceiptSizeServiceListResponse = + IntBlockReceiptSizeServiceListResponses[keyof IntBlockReceiptSizeServiceListResponses]; + +export type IntBlockReceiptSizeServiceGetData = { + body?: never; + path: { + /** + * The block number + */ + block_number: number; + }; + query?: never; + url: '/api/v1/int_block_receipt_size/{block_number}'; +}; + +export type IntBlockReceiptSizeServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntBlockReceiptSizeServiceGetError = + IntBlockReceiptSizeServiceGetErrors[keyof IntBlockReceiptSizeServiceGetErrors]; + +export type IntBlockReceiptSizeServiceGetResponses = { + /** + * OK + */ + 200: GetIntBlockReceiptSizeResponse; +}; + +export type IntBlockReceiptSizeServiceGetResponse = + IntBlockReceiptSizeServiceGetResponses[keyof IntBlockReceiptSizeServiceGetResponses]; + export type IntBlockResourceGasServiceListData = { body?: never; path?: never; @@ -95189,6 +97365,430 @@ export type IntTransactionOpcodeGasServiceGetResponses = { export type IntTransactionOpcodeGasServiceGetResponse = IntTransactionOpcodeGasServiceGetResponses[keyof IntTransactionOpcodeGasServiceGetResponses]; +export type IntTransactionReceiptSizeServiceListData = { + 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 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; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: eq) + */ + receipt_bytes_eq?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: ne) + */ + receipt_bytes_ne?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: lt) + */ + receipt_bytes_lt?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: lte) + */ + receipt_bytes_lte?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: gt) + */ + receipt_bytes_gt?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: gte) + */ + receipt_bytes_gte?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: between_min) + */ + receipt_bytes_between_min?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: between_max_value) + */ + receipt_bytes_between_max_value?: number; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: in_values) (comma-separated list) + */ + receipt_bytes_in_values?: string; + /** + * Exact RLP-encoded receipt size in bytes (matches eth_getTransactionReceipt) (filter: not_in_values) (comma-separated list) + */ + receipt_bytes_not_in_values?: string; + /** + * Number of logs emitted by this transaction (filter: eq) + */ + log_count_eq?: number; + /** + * Number of logs emitted by this transaction (filter: ne) + */ + log_count_ne?: number; + /** + * Number of logs emitted by this transaction (filter: lt) + */ + log_count_lt?: number; + /** + * Number of logs emitted by this transaction (filter: lte) + */ + log_count_lte?: number; + /** + * Number of logs emitted by this transaction (filter: gt) + */ + log_count_gt?: number; + /** + * Number of logs emitted by this transaction (filter: gte) + */ + log_count_gte?: number; + /** + * Number of logs emitted by this transaction (filter: between_min) + */ + log_count_between_min?: number; + /** + * Number of logs emitted by this transaction (filter: between_max_value) + */ + log_count_between_max_value?: number; + /** + * Number of logs emitted by this transaction (filter: in_values) (comma-separated list) + */ + log_count_in_values?: string; + /** + * Number of logs emitted by this transaction (filter: not_in_values) (comma-separated list) + */ + log_count_not_in_values?: string; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: eq) + */ + log_data_bytes_eq?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: ne) + */ + log_data_bytes_ne?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: lt) + */ + log_data_bytes_lt?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: lte) + */ + log_data_bytes_lte?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: gt) + */ + log_data_bytes_gt?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: gte) + */ + log_data_bytes_gte?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: between_min) + */ + log_data_bytes_between_min?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: between_max_value) + */ + log_data_bytes_between_max_value?: number; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: in_values) (comma-separated list) + */ + log_data_bytes_in_values?: string; + /** + * Total raw bytes of log data fields (before RLP encoding) (filter: not_in_values) (comma-separated list) + */ + log_data_bytes_not_in_values?: string; + /** + * Total number of topics across all logs (filter: eq) + */ + log_topic_count_eq?: number; + /** + * Total number of topics across all logs (filter: ne) + */ + log_topic_count_ne?: number; + /** + * Total number of topics across all logs (filter: lt) + */ + log_topic_count_lt?: number; + /** + * Total number of topics across all logs (filter: lte) + */ + log_topic_count_lte?: number; + /** + * Total number of topics across all logs (filter: gt) + */ + log_topic_count_gt?: number; + /** + * Total number of topics across all logs (filter: gte) + */ + log_topic_count_gte?: number; + /** + * Total number of topics across all logs (filter: between_min) + */ + log_topic_count_between_min?: number; + /** + * Total number of topics across all logs (filter: between_max_value) + */ + log_topic_count_between_max_value?: number; + /** + * Total number of topics across all logs (filter: in_values) (comma-separated list) + */ + log_topic_count_in_values?: string; + /** + * Total number of topics across all logs (filter: not_in_values) (comma-separated list) + */ + log_topic_count_not_in_values?: string; + /** + * The maximum number of int_transaction_receipt_size 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 `ListIntTransactionReceiptSize` 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_receipt_size'; +}; + +export type IntTransactionReceiptSizeServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionReceiptSizeServiceListError = + IntTransactionReceiptSizeServiceListErrors[keyof IntTransactionReceiptSizeServiceListErrors]; + +export type IntTransactionReceiptSizeServiceListResponses = { + /** + * OK + */ + 200: ListIntTransactionReceiptSizeResponse; +}; + +export type IntTransactionReceiptSizeServiceListResponse = + IntTransactionReceiptSizeServiceListResponses[keyof IntTransactionReceiptSizeServiceListResponses]; + +export type IntTransactionReceiptSizeServiceGetData = { + body?: never; + path: { + /** + * The block number containing the transaction + */ + block_number: number; + }; + query?: never; + url: '/api/v1/int_transaction_receipt_size/{block_number}'; +}; + +export type IntTransactionReceiptSizeServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type IntTransactionReceiptSizeServiceGetError = + IntTransactionReceiptSizeServiceGetErrors[keyof IntTransactionReceiptSizeServiceGetErrors]; + +export type IntTransactionReceiptSizeServiceGetResponses = { + /** + * OK + */ + 200: GetIntTransactionReceiptSizeResponse; +}; + +export type IntTransactionReceiptSizeServiceGetResponse = + IntTransactionReceiptSizeServiceGetResponses[keyof IntTransactionReceiptSizeServiceGetResponses]; + export type IntTransactionResourceGasServiceListData = { body?: never; path?: never; diff --git a/src/api/zod.gen.ts b/src/api/zod.gen.ts index 593805c99..6aa6fa73a 100644 --- a/src/api/zod.gen.ts +++ b/src/api/zod.gen.ts @@ -5671,6 +5671,287 @@ export const zFctExecutionGasUsedHourly = z.object({ ), }); +export const zFctExecutionReceiptSizeDaily = z.object({ + avg_log_count_per_transaction: z.optional(z.number()), + avg_receipt_bytes_per_block: z.optional(z.number()), + avg_receipt_bytes_per_transaction: z.optional(z.number()), + block_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + cumulative_receipt_bytes: 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', + }) + ) + ), + day_start_date: z.optional(z.string()), + lower_band_receipt_bytes_per_block: z.optional(z.number()), + max_receipt_bytes_per_block: 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', + }) + ) + ), + min_receipt_bytes_per_block: 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', + }) + ) + ), + moving_avg_receipt_bytes_per_block: z.optional(z.number()), + p05_receipt_bytes_per_block: 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', + }) + ) + ), + p50_receipt_bytes_per_block: 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', + }) + ) + ), + p50_receipt_bytes_per_transaction: 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', + }) + ) + ), + p95_receipt_bytes_per_block: 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', + }) + ) + ), + p95_receipt_bytes_per_transaction: 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', + }) + ) + ), + stddev_receipt_bytes_per_block: z.optional(z.number()), + total_log_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', + }) + ) + ), + total_receipt_bytes: 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', + }) + ) + ), + transaction_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', + }) + ) + ), + 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' }) + ) + ), + upper_band_receipt_bytes_per_block: z.optional(z.number()), +}); + +export const zFctExecutionReceiptSizeHourly = z.object({ + avg_log_count_per_transaction: z.optional(z.number()), + avg_receipt_bytes_per_block: z.optional(z.number()), + avg_receipt_bytes_per_transaction: z.optional(z.number()), + block_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + cumulative_receipt_bytes: 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', + }) + ) + ), + hour_start_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' }) + ) + ), + lower_band_receipt_bytes_per_block: z.optional(z.number()), + max_receipt_bytes_per_block: 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', + }) + ) + ), + min_receipt_bytes_per_block: 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', + }) + ) + ), + moving_avg_receipt_bytes_per_block: z.optional(z.number()), + p05_receipt_bytes_per_block: 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', + }) + ) + ), + p50_receipt_bytes_per_block: 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', + }) + ) + ), + p50_receipt_bytes_per_transaction: 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', + }) + ) + ), + p95_receipt_bytes_per_block: 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', + }) + ) + ), + p95_receipt_bytes_per_transaction: 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', + }) + ) + ), + stddev_receipt_bytes_per_block: z.optional(z.number()), + total_log_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', + }) + ) + ), + total_receipt_bytes: 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', + }) + ) + ), + transaction_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', + }) + ) + ), + 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' }) + ) + ), + upper_band_receipt_bytes_per_block: z.optional(z.number()), +}); + export const zFctExecutionStateSizeDaily = z.object({ account_bytes: z.optional( z.coerce @@ -8791,6 +9072,20 @@ export const zGetFctExecutionGasUsedHourlyResponse = z.object({ item: z.optional(zFctExecutionGasUsedHourly), }); +/** + * Response for getting a single fct_execution_receipt_size_daily record + */ +export const zGetFctExecutionReceiptSizeDailyResponse = z.object({ + item: z.optional(zFctExecutionReceiptSizeDaily), +}); + +/** + * Response for getting a single fct_execution_receipt_size_hourly record + */ +export const zGetFctExecutionReceiptSizeHourlyResponse = z.object({ + item: z.optional(zFctExecutionReceiptSizeHourly), +}); + /** * Response for getting a single fct_execution_state_size_daily record */ @@ -10041,6 +10336,110 @@ export const zGetIntBlockProposerCanonicalResponse = z.object({ item: z.optional(zIntBlockProposerCanonical), }); +export const zIntBlockReceiptSize = z.object({ + avg_receipt_bytes_per_transaction: z.optional(z.number()), + 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', + }) + ) + ), + log_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + log_data_bytes: 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', + }) + ) + ), + log_topic_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_receipt_bytes_per_transaction: 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()), + p50_receipt_bytes_per_transaction: 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', + }) + ) + ), + p95_receipt_bytes_per_transaction: 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', + }) + ) + ), + receipt_bytes: 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', + }) + ) + ), + transaction_count: z.optional( + z + .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_block_receipt_size record + */ +export const zGetIntBlockReceiptSizeResponse = z.object({ + item: z.optional(zIntBlockReceiptSize), +}); + export const zIntBlockResourceGas = z.object({ block_number: z.optional( z.coerce @@ -13651,6 +14050,80 @@ export const zGetIntTransactionOpcodeGasResponse = z.object({ item: z.optional(zIntTransactionOpcodeGas), }); +export const zIntTransactionReceiptSize = 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', + }) + ) + ), + log_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + log_data_bytes: 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', + }) + ) + ), + log_topic_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + meta_network_name: z.optional(z.string()), + receipt_bytes: 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', + }) + ) + ), + 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_receipt_size record + */ +export const zGetIntTransactionReceiptSizeResponse = z.object({ + item: z.optional(zIntTransactionReceiptSize), +}); + export const zIntTransactionResourceGas = z.object({ block_number: z.optional( z.coerce @@ -14385,6 +14858,22 @@ export const zListFctExecutionGasUsedHourlyResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing fct_execution_receipt_size_daily records + */ +export const zListFctExecutionReceiptSizeDailyResponse = z.object({ + fct_execution_receipt_size_daily: z.optional(z.array(zFctExecutionReceiptSizeDaily)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_execution_receipt_size_hourly records + */ +export const zListFctExecutionReceiptSizeHourlyResponse = z.object({ + fct_execution_receipt_size_hourly: z.optional(z.array(zFctExecutionReceiptSizeHourly)), + next_page_token: z.optional(z.string()), +}); + /** * Response for listing fct_execution_state_size_daily records */ @@ -14857,6 +15346,14 @@ export const zListIntBlockProposerCanonicalResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing int_block_receipt_size records + */ +export const zListIntBlockReceiptSizeResponse = z.object({ + int_block_receipt_size: z.optional(z.array(zIntBlockReceiptSize)), + next_page_token: z.optional(z.string()), +}); + /** * Response for listing int_block_resource_gas records */ @@ -15267,6 +15764,14 @@ export const zListIntTransactionOpcodeGasResponse = z.object({ next_page_token: z.optional(z.string()), }); +/** + * Response for listing int_transaction_receipt_size records + */ +export const zListIntTransactionReceiptSizeResponse = z.object({ + int_transaction_receipt_size: z.optional(z.array(zIntTransactionReceiptSize)), + next_page_token: z.optional(z.string()), +}); + /** * Response for listing int_transaction_resource_gas records */ @@ -61985,7 +62490,7 @@ export const zFctExecutionGasUsedHourlyServiceGetData = z.object({ */ export const zFctExecutionGasUsedHourlyServiceGetResponse = zGetFctExecutionGasUsedHourlyResponse; -export const zFctExecutionStateSizeDailyServiceListData = z.object({ +export const zFctExecutionReceiptSizeDailyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -62065,7 +62570,73 @@ export const zFctExecutionStateSizeDailyServiceListData = 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+)*$/))), - accounts_eq: z.optional( + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_eq: z.optional( z.coerce .bigint() .check( @@ -62075,7 +62646,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_ne: z.optional( + transaction_count_ne: z.optional( z.coerce .bigint() .check( @@ -62085,7 +62656,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_lt: z.optional( + transaction_count_lt: z.optional( z.coerce .bigint() .check( @@ -62095,7 +62666,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_lte: z.optional( + transaction_count_lte: z.optional( z.coerce .bigint() .check( @@ -62105,7 +62676,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_gt: z.optional( + transaction_count_gt: z.optional( z.coerce .bigint() .check( @@ -62115,7 +62686,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_gte: z.optional( + transaction_count_gte: z.optional( z.coerce .bigint() .check( @@ -62125,7 +62696,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_between_min: z.optional( + transaction_count_between_min: z.optional( z.coerce .bigint() .check( @@ -62135,7 +62706,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_between_max_value: z.optional( + transaction_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62145,9 +62716,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - accounts_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - accounts_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_bytes_eq: z.optional( + transaction_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -62157,7 +62728,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_ne: z.optional( + total_receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -62167,7 +62738,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_lt: z.optional( + total_receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -62177,7 +62748,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_lte: z.optional( + total_receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -62187,7 +62758,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_gt: z.optional( + total_receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -62197,7 +62768,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_gte: z.optional( + total_receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -62207,7 +62778,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_between_min: z.optional( + total_receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -62217,7 +62788,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_between_max_value: z.optional( + total_receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62227,9 +62798,10 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienodes_eq: z.optional( + total_receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_receipt_bytes_per_block_value: z.optional(z.number()), + min_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -62239,7 +62811,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_ne: z.optional( + min_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -62249,7 +62821,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_lt: z.optional( + min_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -62259,7 +62831,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_lte: z.optional( + min_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -62269,7 +62841,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_gt: z.optional( + min_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -62279,7 +62851,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_gte: z.optional( + min_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -62289,7 +62861,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_between_min: z.optional( + min_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -62299,7 +62871,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_between_max_value: z.optional( + min_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62309,9 +62881,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienode_bytes_eq: z.optional( + min_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -62321,7 +62893,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_ne: z.optional( + max_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -62331,7 +62903,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_lt: z.optional( + max_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -62341,7 +62913,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_lte: z.optional( + max_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -62351,7 +62923,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_gt: z.optional( + max_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -62361,7 +62933,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_gte: z.optional( + max_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -62371,7 +62943,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_between_min: z.optional( + max_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -62381,7 +62953,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_between_max_value: z.optional( + max_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62391,9 +62963,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - account_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_codes_eq: z.optional( + max_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -62403,7 +62975,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_ne: z.optional( + p05_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -62413,7 +62985,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_lt: z.optional( + p05_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -62423,7 +62995,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_lte: z.optional( + p05_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -62433,7 +63005,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_gt: z.optional( + p05_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -62443,7 +63015,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_gte: z.optional( + p05_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -62453,7 +63025,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_between_min: z.optional( + p05_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -62463,7 +63035,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_between_max_value: z.optional( + p05_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62473,9 +63045,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_codes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_codes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_code_bytes_eq: z.optional( + p05_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -62485,7 +63057,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_ne: z.optional( + p50_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -62495,7 +63067,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_lt: z.optional( + p50_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -62505,7 +63077,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_lte: z.optional( + p50_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -62515,7 +63087,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_gt: z.optional( + p50_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -62525,7 +63097,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_gte: z.optional( + p50_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -62535,7 +63107,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_between_min: z.optional( + p50_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -62545,7 +63117,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_between_max_value: z.optional( + p50_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62555,9 +63127,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - contract_code_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_code_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storages_eq: z.optional( + p50_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -62567,7 +63139,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_ne: z.optional( + p95_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -62577,7 +63149,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_lt: z.optional( + p95_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -62587,7 +63159,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_lte: z.optional( + p95_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -62597,7 +63169,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_gt: z.optional( + p95_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -62607,7 +63179,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_gte: z.optional( + p95_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -62617,7 +63189,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_between_min: z.optional( + p95_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -62627,7 +63199,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_between_max_value: z.optional( + p95_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62637,9 +63209,14 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storages_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storages_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_bytes_eq: z.optional( + p95_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + stddev_receipt_bytes_per_block_value: z.optional(z.number()), + upper_band_receipt_bytes_per_block_value: z.optional(z.number()), + lower_band_receipt_bytes_per_block_value: z.optional(z.number()), + moving_avg_receipt_bytes_per_block_value: z.optional(z.number()), + avg_receipt_bytes_per_transaction_value: z.optional(z.number()), + p50_receipt_bytes_per_transaction_eq: z.optional( z.coerce .bigint() .check( @@ -62649,7 +63226,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_ne: z.optional( + p50_receipt_bytes_per_transaction_ne: z.optional( z.coerce .bigint() .check( @@ -62659,7 +63236,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_lt: z.optional( + p50_receipt_bytes_per_transaction_lt: z.optional( z.coerce .bigint() .check( @@ -62669,7 +63246,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_lte: z.optional( + p50_receipt_bytes_per_transaction_lte: z.optional( z.coerce .bigint() .check( @@ -62679,7 +63256,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_gt: z.optional( + p50_receipt_bytes_per_transaction_gt: z.optional( z.coerce .bigint() .check( @@ -62689,7 +63266,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_gte: z.optional( + p50_receipt_bytes_per_transaction_gte: z.optional( z.coerce .bigint() .check( @@ -62699,7 +63276,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_between_min: z.optional( + p50_receipt_bytes_per_transaction_between_min: z.optional( z.coerce .bigint() .check( @@ -62709,7 +63286,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_between_max_value: z.optional( + p50_receipt_bytes_per_transaction_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62719,9 +63296,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienodes_eq: z.optional( + p50_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_eq: z.optional( z.coerce .bigint() .check( @@ -62731,7 +63308,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_ne: z.optional( + p95_receipt_bytes_per_transaction_ne: z.optional( z.coerce .bigint() .check( @@ -62741,7 +63318,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_lt: z.optional( + p95_receipt_bytes_per_transaction_lt: z.optional( z.coerce .bigint() .check( @@ -62751,7 +63328,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_lte: z.optional( + p95_receipt_bytes_per_transaction_lte: z.optional( z.coerce .bigint() .check( @@ -62761,7 +63338,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_gt: z.optional( + p95_receipt_bytes_per_transaction_gt: z.optional( z.coerce .bigint() .check( @@ -62771,7 +63348,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_gte: z.optional( + p95_receipt_bytes_per_transaction_gte: z.optional( z.coerce .bigint() .check( @@ -62781,7 +63358,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_between_min: z.optional( + p95_receipt_bytes_per_transaction_between_min: z.optional( z.coerce .bigint() .check( @@ -62791,7 +63368,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_between_max_value: z.optional( + p95_receipt_bytes_per_transaction_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62801,9 +63378,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienode_bytes_eq: z.optional( + p95_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_log_count_eq: z.optional( z.coerce .bigint() .check( @@ -62813,7 +63390,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_ne: z.optional( + total_log_count_ne: z.optional( z.coerce .bigint() .check( @@ -62823,7 +63400,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_lt: z.optional( + total_log_count_lt: z.optional( z.coerce .bigint() .check( @@ -62833,7 +63410,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_lte: z.optional( + total_log_count_lte: z.optional( z.coerce .bigint() .check( @@ -62843,7 +63420,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_gt: z.optional( + total_log_count_gt: z.optional( z.coerce .bigint() .check( @@ -62853,7 +63430,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_gte: z.optional( + total_log_count_gte: z.optional( z.coerce .bigint() .check( @@ -62863,7 +63440,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_between_min: z.optional( + total_log_count_between_min: z.optional( z.coerce .bigint() .check( @@ -62873,7 +63450,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_between_max_value: z.optional( + total_log_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62883,9 +63460,10 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_bytes_eq: z.optional( + total_log_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_log_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_log_count_per_transaction_value: z.optional(z.number()), + cumulative_receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -62895,7 +63473,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_ne: z.optional( + cumulative_receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -62905,7 +63483,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_lt: z.optional( + cumulative_receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -62915,7 +63493,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_lte: z.optional( + cumulative_receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -62925,7 +63503,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_gt: z.optional( + cumulative_receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -62935,7 +63513,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_gte: z.optional( + cumulative_receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -62945,7 +63523,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_between_min: z.optional( + cumulative_receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -62955,7 +63533,7 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_between_max_value: z.optional( + cumulative_receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -62965,8 +63543,8 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ }) ) ), - total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -62984,9 +63562,9 @@ export const zFctExecutionStateSizeDailyServiceListData = z.object({ /** * OK */ -export const zFctExecutionStateSizeDailyServiceListResponse = zListFctExecutionStateSizeDailyResponse; +export const zFctExecutionReceiptSizeDailyServiceListResponse = zListFctExecutionReceiptSizeDailyResponse; -export const zFctExecutionStateSizeDailyServiceGetData = z.object({ +export const zFctExecutionReceiptSizeDailyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ day_start_date: z.string(), @@ -62997,9 +63575,9 @@ export const zFctExecutionStateSizeDailyServiceGetData = z.object({ /** * OK */ -export const zFctExecutionStateSizeDailyServiceGetResponse = zGetFctExecutionStateSizeDailyResponse; +export const zFctExecutionReceiptSizeDailyServiceGetResponse = zGetFctExecutionReceiptSizeDailyResponse; -export const zFctExecutionStateSizeHourlyServiceListData = z.object({ +export const zFctExecutionReceiptSizeHourlyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -63136,7 +63714,73 @@ export const zFctExecutionStateSizeHourlyServiceListData = 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+)*$/))), - accounts_eq: z.optional( + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_eq: z.optional( z.coerce .bigint() .check( @@ -63146,7 +63790,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_ne: z.optional( + transaction_count_ne: z.optional( z.coerce .bigint() .check( @@ -63156,7 +63800,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_lt: z.optional( + transaction_count_lt: z.optional( z.coerce .bigint() .check( @@ -63166,7 +63810,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_lte: z.optional( + transaction_count_lte: z.optional( z.coerce .bigint() .check( @@ -63176,7 +63820,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_gt: z.optional( + transaction_count_gt: z.optional( z.coerce .bigint() .check( @@ -63186,7 +63830,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_gte: z.optional( + transaction_count_gte: z.optional( z.coerce .bigint() .check( @@ -63196,7 +63840,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_between_min: z.optional( + transaction_count_between_min: z.optional( z.coerce .bigint() .check( @@ -63206,7 +63850,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_between_max_value: z.optional( + transaction_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63216,9 +63860,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - accounts_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - accounts_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_bytes_eq: z.optional( + transaction_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -63228,7 +63872,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_ne: z.optional( + total_receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -63238,7 +63882,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_lt: z.optional( + total_receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -63248,7 +63892,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_lte: z.optional( + total_receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -63258,7 +63902,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_gt: z.optional( + total_receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -63268,7 +63912,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_gte: z.optional( + total_receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -63278,7 +63922,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_between_min: z.optional( + total_receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -63288,7 +63932,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_between_max_value: z.optional( + total_receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63298,9 +63942,10 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienodes_eq: z.optional( + total_receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_receipt_bytes_per_block_value: z.optional(z.number()), + min_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -63310,7 +63955,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_ne: z.optional( + min_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -63320,7 +63965,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_lt: z.optional( + min_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -63330,7 +63975,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_lte: z.optional( + min_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -63340,7 +63985,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_gt: z.optional( + min_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -63350,7 +63995,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_gte: z.optional( + min_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -63360,7 +64005,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_between_min: z.optional( + min_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -63370,7 +64015,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_between_max_value: z.optional( + min_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63380,9 +64025,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienode_bytes_eq: z.optional( + min_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -63392,7 +64037,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_ne: z.optional( + max_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -63402,7 +64047,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_lt: z.optional( + max_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -63412,7 +64057,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_lte: z.optional( + max_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -63422,7 +64067,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_gt: z.optional( + max_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -63432,7 +64077,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_gte: z.optional( + max_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -63442,7 +64087,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_between_min: z.optional( + max_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -63452,7 +64097,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_between_max_value: z.optional( + max_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63462,9 +64107,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - account_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - account_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_codes_eq: z.optional( + max_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -63474,7 +64119,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_ne: z.optional( + p05_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -63484,7 +64129,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_lt: z.optional( + p05_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -63494,7 +64139,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_lte: z.optional( + p05_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -63504,7 +64149,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_gt: z.optional( + p05_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -63514,7 +64159,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_gte: z.optional( + p05_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -63524,7 +64169,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_between_min: z.optional( + p05_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -63534,7 +64179,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_between_max_value: z.optional( + p05_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63544,9 +64189,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_codes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_codes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_code_bytes_eq: z.optional( + p05_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -63556,7 +64201,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_ne: z.optional( + p50_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -63566,7 +64211,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_lt: z.optional( + p50_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -63576,7 +64221,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_lte: z.optional( + p50_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -63586,7 +64231,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_gt: z.optional( + p50_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -63596,7 +64241,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_gte: z.optional( + p50_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -63606,7 +64251,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_between_min: z.optional( + p50_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -63616,7 +64261,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_between_max_value: z.optional( + p50_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63626,9 +64271,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - contract_code_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - contract_code_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storages_eq: z.optional( + p50_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_block_eq: z.optional( z.coerce .bigint() .check( @@ -63638,7 +64283,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_ne: z.optional( + p95_receipt_bytes_per_block_ne: z.optional( z.coerce .bigint() .check( @@ -63648,7 +64293,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_lt: z.optional( + p95_receipt_bytes_per_block_lt: z.optional( z.coerce .bigint() .check( @@ -63658,7 +64303,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_lte: z.optional( + p95_receipt_bytes_per_block_lte: z.optional( z.coerce .bigint() .check( @@ -63668,7 +64313,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_gt: z.optional( + p95_receipt_bytes_per_block_gt: z.optional( z.coerce .bigint() .check( @@ -63678,7 +64323,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_gte: z.optional( + p95_receipt_bytes_per_block_gte: z.optional( z.coerce .bigint() .check( @@ -63688,7 +64333,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_between_min: z.optional( + p95_receipt_bytes_per_block_between_min: z.optional( z.coerce .bigint() .check( @@ -63698,7 +64343,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_between_max_value: z.optional( + p95_receipt_bytes_per_block_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63708,9 +64353,14 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storages_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storages_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_bytes_eq: z.optional( + p95_receipt_bytes_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + stddev_receipt_bytes_per_block_value: z.optional(z.number()), + upper_band_receipt_bytes_per_block_value: z.optional(z.number()), + lower_band_receipt_bytes_per_block_value: z.optional(z.number()), + moving_avg_receipt_bytes_per_block_value: z.optional(z.number()), + avg_receipt_bytes_per_transaction_value: z.optional(z.number()), + p50_receipt_bytes_per_transaction_eq: z.optional( z.coerce .bigint() .check( @@ -63720,7 +64370,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_ne: z.optional( + p50_receipt_bytes_per_transaction_ne: z.optional( z.coerce .bigint() .check( @@ -63730,7 +64380,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_lt: z.optional( + p50_receipt_bytes_per_transaction_lt: z.optional( z.coerce .bigint() .check( @@ -63740,7 +64390,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_lte: z.optional( + p50_receipt_bytes_per_transaction_lte: z.optional( z.coerce .bigint() .check( @@ -63750,7 +64400,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_gt: z.optional( + p50_receipt_bytes_per_transaction_gt: z.optional( z.coerce .bigint() .check( @@ -63760,7 +64410,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_gte: z.optional( + p50_receipt_bytes_per_transaction_gte: z.optional( z.coerce .bigint() .check( @@ -63770,7 +64420,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_between_min: z.optional( + p50_receipt_bytes_per_transaction_between_min: z.optional( z.coerce .bigint() .check( @@ -63780,7 +64430,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_between_max_value: z.optional( + p50_receipt_bytes_per_transaction_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63790,9 +64440,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienodes_eq: z.optional( + p50_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_eq: z.optional( z.coerce .bigint() .check( @@ -63802,7 +64452,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_ne: z.optional( + p95_receipt_bytes_per_transaction_ne: z.optional( z.coerce .bigint() .check( @@ -63812,7 +64462,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_lt: z.optional( + p95_receipt_bytes_per_transaction_lt: z.optional( z.coerce .bigint() .check( @@ -63822,7 +64472,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_lte: z.optional( + p95_receipt_bytes_per_transaction_lte: z.optional( z.coerce .bigint() .check( @@ -63832,7 +64482,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_gt: z.optional( + p95_receipt_bytes_per_transaction_gt: z.optional( z.coerce .bigint() .check( @@ -63842,7 +64492,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_gte: z.optional( + p95_receipt_bytes_per_transaction_gte: z.optional( z.coerce .bigint() .check( @@ -63852,7 +64502,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_between_min: z.optional( + p95_receipt_bytes_per_transaction_between_min: z.optional( z.coerce .bigint() .check( @@ -63862,7 +64512,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_between_max_value: z.optional( + p95_receipt_bytes_per_transaction_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63872,9 +64522,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienode_bytes_eq: z.optional( + p95_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_log_count_eq: z.optional( z.coerce .bigint() .check( @@ -63884,7 +64534,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_ne: z.optional( + total_log_count_ne: z.optional( z.coerce .bigint() .check( @@ -63894,7 +64544,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_lt: z.optional( + total_log_count_lt: z.optional( z.coerce .bigint() .check( @@ -63904,7 +64554,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_lte: z.optional( + total_log_count_lte: z.optional( z.coerce .bigint() .check( @@ -63914,7 +64564,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_gt: z.optional( + total_log_count_gt: z.optional( z.coerce .bigint() .check( @@ -63924,7 +64574,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_gte: z.optional( + total_log_count_gte: z.optional( z.coerce .bigint() .check( @@ -63934,7 +64584,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_between_min: z.optional( + total_log_count_between_min: z.optional( z.coerce .bigint() .check( @@ -63944,7 +64594,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_between_max_value: z.optional( + total_log_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -63954,9 +64604,10 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - storage_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - storage_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_bytes_eq: z.optional( + total_log_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_log_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_log_count_per_transaction_value: z.optional(z.number()), + cumulative_receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -63966,7 +64617,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_ne: z.optional( + cumulative_receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -63976,7 +64627,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_lt: z.optional( + cumulative_receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -63986,7 +64637,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_lte: z.optional( + cumulative_receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -63996,7 +64647,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_gt: z.optional( + cumulative_receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -64006,7 +64657,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_gte: z.optional( + cumulative_receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -64016,7 +64667,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_between_min: z.optional( + cumulative_receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -64026,7 +64677,7 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_between_max_value: z.optional( + cumulative_receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -64036,8 +64687,8 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ }) ) ), - total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -64055,9 +64706,9 @@ export const zFctExecutionStateSizeHourlyServiceListData = z.object({ /** * OK */ -export const zFctExecutionStateSizeHourlyServiceListResponse = zListFctExecutionStateSizeHourlyResponse; +export const zFctExecutionReceiptSizeHourlyServiceListResponse = zListFctExecutionReceiptSizeHourlyResponse; -export const zFctExecutionStateSizeHourlyServiceGetData = z.object({ +export const zFctExecutionReceiptSizeHourlyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ hour_start_date_time: z @@ -64073,9 +64724,9 @@ export const zFctExecutionStateSizeHourlyServiceGetData = z.object({ /** * OK */ -export const zFctExecutionStateSizeHourlyServiceGetResponse = zGetFctExecutionStateSizeHourlyResponse; +export const zFctExecutionReceiptSizeHourlyServiceGetResponse = zGetFctExecutionReceiptSizeHourlyResponse; -export const zFctExecutionTpsDailyServiceListData = z.object({ +export const zFctExecutionStateSizeDailyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -64155,73 +64806,89 @@ export const zFctExecutionTpsDailyServiceListData = 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+)*$/))), - block_count_eq: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_ne: z.optional( - z - .int() + accounts_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_count_lt: z.optional( - z - .int() + accounts_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_count_lte: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_gt: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_gte: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_between_min: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_between_max_value: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_eq: z.optional( + accounts_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + accounts_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -64231,7 +64898,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_ne: z.optional( + account_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -64241,7 +64908,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_lt: z.optional( + account_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -64251,7 +64918,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_lte: z.optional( + account_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -64261,7 +64928,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_gt: z.optional( + account_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -64271,7 +64938,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_gte: z.optional( + account_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -64281,7 +64948,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_between_min: z.optional( + account_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -64291,7 +64958,7 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_between_max_value: z.optional( + account_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -64301,320 +64968,141 @@ export const zFctExecutionTpsDailyServiceListData = z.object({ }) ) ), - total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_seconds_eq: z.optional( - z - .int() + account_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienodes_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', + }) ) ), - total_seconds_ne: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_lt: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_lte: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_gt: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_gte: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_between_min: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_between_max_value: z.optional( - z - .int() + account_trienodes_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', + }) ) ), - total_seconds_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_seconds_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - avg_tps_value: z.optional(z.number()), - min_tps_value: z.optional(z.number()), - max_tps_value: z.optional(z.number()), - p05_tps_value: z.optional(z.number()), - p50_tps_value: z.optional(z.number()), - p95_tps_value: z.optional(z.number()), - stddev_tps_value: z.optional(z.number()), - upper_band_tps_value: z.optional(z.number()), - lower_band_tps_value: z.optional(z.number()), - moving_avg_tps_value: z.optional(z.number()), - page_size: z.optional( - z - .int() + account_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienode_bytes_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 zFctExecutionTpsDailyServiceListResponse = zListFctExecutionTpsDailyResponse; - -export const zFctExecutionTpsDailyServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - day_start_date: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zFctExecutionTpsDailyServiceGetResponse = zGetFctExecutionTpsDailyResponse; - -export const zFctExecutionTpsHourlyServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - hour_start_date_time_eq: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - hour_start_date_time_ne: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - hour_start_date_time_lt: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - hour_start_date_time_lte: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - hour_start_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' }) - ) - ), - hour_start_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' }) - ) - ), - hour_start_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' }) - ) - ), - hour_start_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' }) - ) - ), - hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - hour_start_date_time_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+)*$/))), - block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_eq: z.optional( + account_trienode_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -64624,7 +65112,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_ne: z.optional( + account_trienode_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -64634,7 +65122,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_lt: z.optional( + account_trienode_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -64644,7 +65132,9 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_lte: z.optional( + account_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_codes_eq: z.optional( z.coerce .bigint() .check( @@ -64654,7 +65144,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_gt: z.optional( + contract_codes_ne: z.optional( z.coerce .bigint() .check( @@ -64664,7 +65154,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_gte: z.optional( + contract_codes_lt: z.optional( z.coerce .bigint() .check( @@ -64674,7 +65164,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_between_min: z.optional( + contract_codes_lte: z.optional( z.coerce .bigint() .check( @@ -64684,7 +65174,7 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_between_max_value: z.optional( + contract_codes_gt: z.optional( z.coerce .bigint() .check( @@ -64694,268 +65184,79 @@ export const zFctExecutionTpsHourlyServiceListData = z.object({ }) ) ), - total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_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' }) - ) - ), - total_seconds_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_seconds_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - avg_tps_value: z.optional(z.number()), - min_tps_value: z.optional(z.number()), - max_tps_value: z.optional(z.number()), - p05_tps_value: z.optional(z.number()), - p50_tps_value: z.optional(z.number()), - p95_tps_value: z.optional(z.number()), - stddev_tps_value: z.optional(z.number()), - upper_band_tps_value: z.optional(z.number()), - lower_band_tps_value: z.optional(z.number()), - moving_avg_tps_value: z.optional(z.number()), - 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 zFctExecutionTpsHourlyServiceListResponse = zListFctExecutionTpsHourlyResponse; - -export const zFctExecutionTpsHourlyServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - hour_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 zFctExecutionTpsHourlyServiceGetResponse = zGetFctExecutionTpsHourlyResponse; - -export const zFctExecutionTransactionsDailyServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - day_start_date_eq: z.optional(z.string()), - day_start_date_ne: z.optional(z.string()), - day_start_date_contains: z.optional(z.string()), - day_start_date_starts_with: z.optional(z.string()), - day_start_date_ends_with: z.optional(z.string()), - day_start_date_like: z.optional(z.string()), - day_start_date_not_like: z.optional(z.string()), - day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - day_start_date_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+)*$/))), - block_count_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_count_ne: z.optional( - z - .int() + contract_codes_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', + }) ) ), - block_count_lt: z.optional( - z - .int() + contract_codes_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', + }) ) ), - block_count_lte: z.optional( - z - .int() + contract_codes_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', + }) ) ), - block_count_gt: z.optional( - z - .int() + contract_codes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_codes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_code_bytes_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', + }) ) ), - block_count_gte: z.optional( - z - .int() + contract_code_bytes_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_count_between_min: z.optional( - z - .int() + contract_code_bytes_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_count_between_max_value: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - block_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_eq: z.optional( + contract_code_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -64965,7 +65266,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_ne: z.optional( + contract_code_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -64975,7 +65276,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_lt: z.optional( + contract_code_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -64985,7 +65286,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_lte: z.optional( + contract_code_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -64995,7 +65296,9 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_gt: z.optional( + contract_code_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_code_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storages_eq: z.optional( z.coerce .bigint() .check( @@ -65005,7 +65308,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_gte: z.optional( + storages_ne: z.optional( z.coerce .bigint() .check( @@ -65015,7 +65318,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_between_min: z.optional( + storages_lt: z.optional( z.coerce .bigint() .check( @@ -65025,7 +65328,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_between_max_value: z.optional( + storages_lte: z.optional( z.coerce .bigint() .check( @@ -65035,9 +65338,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - cumulative_transactions_eq: z.optional( + storages_gt: z.optional( z.coerce .bigint() .check( @@ -65047,7 +65348,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_ne: z.optional( + storages_gte: z.optional( z.coerce .bigint() .check( @@ -65057,7 +65358,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_lt: z.optional( + storages_between_min: z.optional( z.coerce .bigint() .check( @@ -65067,7 +65368,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_lte: z.optional( + storages_between_max_value: z.optional( z.coerce .bigint() .check( @@ -65077,7 +65378,9 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_gt: z.optional( + storages_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storages_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -65087,7 +65390,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_gte: z.optional( + storage_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -65097,7 +65400,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_between_min: z.optional( + storage_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -65107,7 +65410,7 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_between_max_value: z.optional( + storage_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -65117,343 +65420,294 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ }) ) ), - cumulative_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - cumulative_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - avg_txn_per_block_value: z.optional(z.number()), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_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' }) - ) - ), - min_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - min_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_txn_per_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' }) - ) - ), - max_txn_per_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' }) - ) - ), - max_txn_per_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' }) - ) - ), - max_txn_per_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' }) - ) - ), - max_txn_per_block_gt: z.optional( - z - .int() + storage_bytes_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', + }) ) ), - max_txn_per_block_gte: z.optional( - z - .int() + storage_bytes_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', + }) ) ), - max_txn_per_block_between_min: z.optional( - z - .int() + storage_bytes_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', + }) ) ), - max_txn_per_block_between_max_value: z.optional( - z - .int() + storage_bytes_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', + }) ) ), - max_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p50_txn_per_block_eq: z.optional( - z - .int() + storage_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienodes_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', + }) ) ), - p50_txn_per_block_ne: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_lt: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_lte: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_gt: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_gte: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_between_min: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_between_max_value: z.optional( - z - .int() + storage_trienodes_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', + }) ) ), - p50_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p50_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p95_txn_per_block_eq: z.optional( - z - .int() + storage_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_ne: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_lt: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_lte: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_gt: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_gte: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_between_min: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_between_max_value: z.optional( - z - .int() + storage_trienode_bytes_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', + }) ) ), - p95_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p95_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p05_txn_per_block_eq: z.optional( - z - .int() + storage_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_bytes_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', + }) ) ), - p05_txn_per_block_ne: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_lt: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_lte: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_gt: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_gte: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_between_min: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_between_max_value: z.optional( - z - .int() + total_bytes_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', + }) ) ), - p05_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p05_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - stddev_txn_per_block_value: z.optional(z.number()), - upper_band_txn_per_block_value: z.optional(z.number()), - lower_band_txn_per_block_value: z.optional(z.number()), - moving_avg_txn_per_block_value: z.optional(z.number()), + total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -65471,9 +65725,9 @@ export const zFctExecutionTransactionsDailyServiceListData = z.object({ /** * OK */ -export const zFctExecutionTransactionsDailyServiceListResponse = zListFctExecutionTransactionsDailyResponse; +export const zFctExecutionStateSizeDailyServiceListResponse = zListFctExecutionStateSizeDailyResponse; -export const zFctExecutionTransactionsDailyServiceGetData = z.object({ +export const zFctExecutionStateSizeDailyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ day_start_date: z.string(), @@ -65484,9 +65738,9 @@ export const zFctExecutionTransactionsDailyServiceGetData = z.object({ /** * OK */ -export const zFctExecutionTransactionsDailyServiceGetResponse = zGetFctExecutionTransactionsDailyResponse; +export const zFctExecutionStateSizeDailyServiceGetResponse = zGetFctExecutionStateSizeDailyResponse; -export const zFctExecutionTransactionsHourlyServiceListData = z.object({ +export const zFctExecutionStateSizeHourlyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -65623,73 +65877,89 @@ export const zFctExecutionTransactionsHourlyServiceListData = 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+)*$/))), - block_count_eq: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_ne: z.optional( - z - .int() + accounts_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_count_lt: z.optional( - z - .int() + accounts_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_count_lte: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_gt: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_gte: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_between_min: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_between_max_value: z.optional( - z - .int() + accounts_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', + }) ) ), - block_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_eq: z.optional( + accounts_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + accounts_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -65699,7 +65969,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_ne: z.optional( + account_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -65709,7 +65979,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_lt: z.optional( + account_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -65719,7 +65989,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_lte: z.optional( + account_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -65729,7 +65999,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_gt: z.optional( + account_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -65739,7 +66009,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_gte: z.optional( + account_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -65749,7 +66019,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_between_min: z.optional( + account_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -65759,7 +66029,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_between_max_value: z.optional( + account_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -65769,9 +66039,9 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - cumulative_transactions_eq: z.optional( + account_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienodes_eq: z.optional( z.coerce .bigint() .check( @@ -65781,7 +66051,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_ne: z.optional( + account_trienodes_ne: z.optional( z.coerce .bigint() .check( @@ -65791,7 +66061,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_lt: z.optional( + account_trienodes_lt: z.optional( z.coerce .bigint() .check( @@ -65801,7 +66071,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_lte: z.optional( + account_trienodes_lte: z.optional( z.coerce .bigint() .check( @@ -65811,7 +66081,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_gt: z.optional( + account_trienodes_gt: z.optional( z.coerce .bigint() .check( @@ -65821,7 +66091,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_gte: z.optional( + account_trienodes_gte: z.optional( z.coerce .bigint() .check( @@ -65831,7 +66101,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_between_min: z.optional( + account_trienodes_between_min: z.optional( z.coerce .bigint() .check( @@ -65841,7 +66111,7 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_between_max_value: z.optional( + account_trienodes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -65851,286 +66121,2757 @@ export const zFctExecutionTransactionsHourlyServiceListData = z.object({ }) ) ), - cumulative_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - cumulative_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - avg_txn_per_block_value: z.optional(z.number()), - min_txn_per_block_eq: z.optional( - z - .int() + account_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_ne: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_lt: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_lte: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_gt: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_gte: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_between_min: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_between_max_value: z.optional( - z - .int() + account_trienode_bytes_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', + }) ) ), - min_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - min_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_txn_per_block_eq: z.optional( - z - .int() + account_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + account_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_codes_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', + }) ) ), - max_txn_per_block_ne: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_lt: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_lte: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_gt: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_gte: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_between_min: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_between_max_value: z.optional( - z - .int() + contract_codes_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', + }) ) ), - max_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p50_txn_per_block_eq: z.optional( - z - .int() + contract_codes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_codes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_ne: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_lt: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_lte: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_gt: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_gte: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_between_min: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_between_max_value: z.optional( - z - .int() + contract_code_bytes_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', + }) ) ), - p50_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p50_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p95_txn_per_block_eq: z.optional( - z - .int() + contract_code_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + contract_code_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storages_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', + }) ) ), - p95_txn_per_block_ne: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_lt: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_lte: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_gt: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_gte: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_between_min: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_between_max_value: z.optional( - z - .int() + storages_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', + }) ) ), - p95_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p95_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - p05_txn_per_block_eq: z.optional( - z - .int() + storages_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storages_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_bytes_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', + }) ) ), - p05_txn_per_block_ne: z.optional( - z - .int() + storage_bytes_ne: z.optional( + z.coerce + .bigint() .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.minimum(BigInt('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), + z.maximum(BigInt('18446744073709551615'), { + error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', + }) + ) + ), + storage_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', + }) + ) + ), + storage_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', + }) + ) + ), + storage_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', + }) + ) + ), + storage_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', + }) + ) + ), + storage_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', + }) + ) + ), + storage_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', + }) + ) + ), + storage_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_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', + }) + ) + ), + storage_trienodes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienodes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_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', + }) + ) + ), + storage_trienode_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + storage_trienode_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_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', + }) + ) + ), + total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_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 zFctExecutionStateSizeHourlyServiceListResponse = zListFctExecutionStateSizeHourlyResponse; + +export const zFctExecutionStateSizeHourlyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + hour_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 zFctExecutionStateSizeHourlyServiceGetResponse = zGetFctExecutionStateSizeHourlyResponse; + +export const zFctExecutionTpsDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_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+)*$/))), + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_seconds_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_tps_value: z.optional(z.number()), + min_tps_value: z.optional(z.number()), + max_tps_value: z.optional(z.number()), + p05_tps_value: z.optional(z.number()), + p50_tps_value: z.optional(z.number()), + p95_tps_value: z.optional(z.number()), + stddev_tps_value: z.optional(z.number()), + upper_band_tps_value: z.optional(z.number()), + lower_band_tps_value: z.optional(z.number()), + moving_avg_tps_value: z.optional(z.number()), + 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 zFctExecutionTpsDailyServiceListResponse = zListFctExecutionTpsDailyResponse; + +export const zFctExecutionTpsDailyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + day_start_date: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctExecutionTpsDailyServiceGetResponse = zGetFctExecutionTpsDailyResponse; + +export const zFctExecutionTpsHourlyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_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+)*$/))), + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_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' }) + ) + ), + total_seconds_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_seconds_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_tps_value: z.optional(z.number()), + min_tps_value: z.optional(z.number()), + max_tps_value: z.optional(z.number()), + p05_tps_value: z.optional(z.number()), + p50_tps_value: z.optional(z.number()), + p95_tps_value: z.optional(z.number()), + stddev_tps_value: z.optional(z.number()), + upper_band_tps_value: z.optional(z.number()), + lower_band_tps_value: z.optional(z.number()), + moving_avg_tps_value: z.optional(z.number()), + 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 zFctExecutionTpsHourlyServiceListResponse = zListFctExecutionTpsHourlyResponse; + +export const zFctExecutionTpsHourlyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + hour_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 zFctExecutionTpsHourlyServiceGetResponse = zGetFctExecutionTpsHourlyResponse; + +export const zFctExecutionTransactionsDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_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+)*$/))), + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_txn_per_block_value: z.optional(z.number()), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) + ) + ), + p05_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + stddev_txn_per_block_value: z.optional(z.number()), + upper_band_txn_per_block_value: z.optional(z.number()), + lower_band_txn_per_block_value: z.optional(z.number()), + moving_avg_txn_per_block_value: z.optional(z.number()), + 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 zFctExecutionTransactionsDailyServiceListResponse = zListFctExecutionTransactionsDailyResponse; + +export const zFctExecutionTransactionsDailyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + day_start_date: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctExecutionTransactionsDailyServiceGetResponse = zGetFctExecutionTransactionsDailyResponse; + +export const zFctExecutionTransactionsHourlyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_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+)*$/))), + block_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_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_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + block_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_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', + }) + ) + ), + total_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_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_transactions_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', + }) + ) + ), + cumulative_transactions_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', + }) + ) + ), + cumulative_transactions_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + cumulative_transactions_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_txn_per_block_value: z.optional(z.number()), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_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' }) + ) + ), + min_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_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' }) + ) + ), + max_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_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' }) + ) + ), + p50_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_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' }) + ) + ), + p95_txn_per_block_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_txn_per_block_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p05_txn_per_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' }) + ) + ), + p05_txn_per_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' }) ) ), @@ -79687,7 +82428,342 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object ), validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - slot_start_date_time_eq: z.optional( + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + slot_start_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' }) + ) + ), + 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+)*$/))), + 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+)*$/))), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + slot_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', + }) + ) + ), + 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+)*$/))), + participated_eq: z.optional(z.boolean()), + participated_ne: z.optional(z.boolean()), + 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 zFctSyncCommitteeParticipationByValidatorServiceListResponse = + zListFctSyncCommitteeParticipationByValidatorResponse; + +export const zFctSyncCommitteeParticipationByValidatorServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + validator_index: z + .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 zFctSyncCommitteeParticipationByValidatorServiceGetResponse = + zGetFctSyncCommitteeParticipationByValidatorResponse; + +export const zFctSyncCommitteeParticipationByValidatorDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_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' }) + ) + ), + validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -79695,7 +82771,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -79703,7 +82779,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -79711,7 +82787,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -79719,7 +82795,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -79727,7 +82803,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -79735,7 +82811,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -79743,7 +82819,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -79751,9 +82827,9 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = 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+)*$/))), - 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+)*$/))), + total_slots_eq: z.optional( z .int() .check( @@ -79761,7 +82837,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + total_slots_ne: z.optional( z .int() .check( @@ -79769,7 +82845,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + total_slots_lt: z.optional( z .int() .check( @@ -79777,7 +82853,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + total_slots_lte: z.optional( z .int() .check( @@ -79785,7 +82861,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + total_slots_gt: z.optional( z .int() .check( @@ -79793,7 +82869,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + total_slots_gte: z.optional( z .int() .check( @@ -79801,7 +82877,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + total_slots_between_min: z.optional( z .int() .check( @@ -79809,7 +82885,7 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + total_slots_between_max_value: z.optional( z .int() .check( @@ -79817,92 +82893,140 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = 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+)*$/))), - slot_eq: z.optional( - z.coerce - .bigint() + total_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + total_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + participated_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' }) ) ), - slot_ne: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_lt: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_lte: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_gt: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_gte: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_between_min: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - slot_between_max_value: z.optional( - z.coerce - .bigint() + participated_count_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' }) ) ), - 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+)*$/))), - participated_eq: z.optional(z.boolean()), - participated_ne: z.optional(z.boolean()), + participated_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + participated_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_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' }) + ) + ), + missed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + missed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -79920,10 +83044,10 @@ export const zFctSyncCommitteeParticipationByValidatorServiceListData = z.object /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorServiceListResponse = - zListFctSyncCommitteeParticipationByValidatorResponse; +export const zFctSyncCommitteeParticipationByValidatorDailyServiceListResponse = + zListFctSyncCommitteeParticipationByValidatorDailyResponse; -export const zFctSyncCommitteeParticipationByValidatorServiceGetData = z.object({ +export const zFctSyncCommitteeParticipationByValidatorDailyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ validator_index: z @@ -79939,10 +83063,10 @@ export const zFctSyncCommitteeParticipationByValidatorServiceGetData = z.object( /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorServiceGetResponse = - zGetFctSyncCommitteeParticipationByValidatorResponse; +export const zFctSyncCommitteeParticipationByValidatorDailyServiceGetResponse = + zGetFctSyncCommitteeParticipationByValidatorDailyResponse; -export const zFctSyncCommitteeParticipationByValidatorDailyServiceListData = z.object({ +export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -80013,15 +83137,72 @@ export const zFctSyncCommitteeParticipationByValidatorDailyServiceListData = z.o ), validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - day_start_date_eq: z.optional(z.string()), - day_start_date_ne: z.optional(z.string()), - day_start_date_contains: z.optional(z.string()), - day_start_date_starts_with: z.optional(z.string()), - day_start_date_ends_with: z.optional(z.string()), - day_start_date_like: z.optional(z.string()), - day_start_date_not_like: z.optional(z.string()), - day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -80303,10 +83484,10 @@ export const zFctSyncCommitteeParticipationByValidatorDailyServiceListData = z.o /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorDailyServiceListResponse = - zListFctSyncCommitteeParticipationByValidatorDailyResponse; +export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListResponse = + zListFctSyncCommitteeParticipationByValidatorHourlyResponse; -export const zFctSyncCommitteeParticipationByValidatorDailyServiceGetData = z.object({ +export const zFctSyncCommitteeParticipationByValidatorHourlyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ validator_index: z @@ -80322,10 +83503,10 @@ export const zFctSyncCommitteeParticipationByValidatorDailyServiceGetData = z.ob /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorDailyServiceGetResponse = - zGetFctSyncCommitteeParticipationByValidatorDailyResponse; +export const zFctSyncCommitteeParticipationByValidatorHourlyServiceGetResponse = + zGetFctSyncCommitteeParticipationByValidatorHourlyResponse; -export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z.object({ +export const zFctValidatorBalanceServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -80396,7 +83577,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. ), validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - hour_start_date_time_eq: z.optional( + epoch_start_date_time_eq: z.optional( z .int() .check( @@ -80404,7 +83585,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_ne: z.optional( + epoch_start_date_time_ne: z.optional( z .int() .check( @@ -80412,7 +83593,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_lt: z.optional( + epoch_start_date_time_lt: z.optional( z .int() .check( @@ -80420,7 +83601,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_lte: z.optional( + epoch_start_date_time_lte: z.optional( z .int() .check( @@ -80428,7 +83609,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_gt: z.optional( + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -80436,7 +83617,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_gte: z.optional( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -80444,7 +83625,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_between_min: z.optional( + epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -80452,7 +83633,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_between_max_value: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -80460,8 +83641,8 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + 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+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -80528,7 +83709,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = 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+)*$/))), - total_slots_eq: z.optional( + epoch_eq: z.optional( z .int() .check( @@ -80536,7 +83717,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_ne: z.optional( + epoch_ne: z.optional( z .int() .check( @@ -80544,7 +83725,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_lt: z.optional( + epoch_lt: z.optional( z .int() .check( @@ -80552,7 +83733,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_lte: z.optional( + epoch_lte: z.optional( z .int() .check( @@ -80560,7 +83741,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_gt: z.optional( + epoch_gt: z.optional( z .int() .check( @@ -80568,7 +83749,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_gte: z.optional( + epoch_gte: z.optional( z .int() .check( @@ -80576,7 +83757,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_between_min: z.optional( + epoch_between_min: z.optional( z .int() .check( @@ -80584,7 +83765,7 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_between_max_value: z.optional( + epoch_between_max_value: z.optional( z .int() .check( @@ -80592,140 +83773,183 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - total_slots_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - total_slots_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - participated_count_eq: z.optional( - z - .int() + 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+)*$/))), + balance_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', + }) ) ), - participated_count_ne: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_lt: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_lte: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_gt: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_gte: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_between_min: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_between_max_value: z.optional( - z - .int() + balance_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', + }) ) ), - participated_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - participated_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - missed_count_eq: z.optional( - z - .int() + balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_balance_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', + }) ) ), - missed_count_ne: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_lt: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_lte: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_gt: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_gte: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_between_min: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_between_max_value: z.optional( - z - .int() + effective_balance_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', + }) ) ), - missed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - missed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + effective_balance_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(/^[^,]+(,[^,]+)*$/))), + slashed_eq: z.optional(z.boolean()), + slashed_ne: z.optional(z.boolean()), page_size: z.optional( z .int() @@ -80743,10 +83967,9 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListData = z. /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorHourlyServiceListResponse = - zListFctSyncCommitteeParticipationByValidatorHourlyResponse; +export const zFctValidatorBalanceServiceListResponse = zListFctValidatorBalanceResponse; -export const zFctSyncCommitteeParticipationByValidatorHourlyServiceGetData = z.object({ +export const zFctValidatorBalanceServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ validator_index: z @@ -80762,10 +83985,9 @@ export const zFctSyncCommitteeParticipationByValidatorHourlyServiceGetData = z.o /** * OK */ -export const zFctSyncCommitteeParticipationByValidatorHourlyServiceGetResponse = - zGetFctSyncCommitteeParticipationByValidatorHourlyResponse; +export const zFctValidatorBalanceServiceGetResponse = zGetFctValidatorBalanceResponse; -export const zFctValidatorBalanceServiceListData = z.object({ +export const zFctValidatorBalanceDailyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -80836,7 +84058,16 @@ export const zFctValidatorBalanceServiceListData = z.object({ ), validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - epoch_start_date_time_eq: z.optional( + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -80844,7 +84075,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -80852,7 +84083,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -80860,7 +84091,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -80868,7 +84099,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -80876,7 +84107,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -80884,7 +84115,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -80892,7 +84123,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -80900,9 +84131,9 @@ export const zFctValidatorBalanceServiceListData = z.object({ 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+)*$/))), - 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+)*$/))), + start_epoch_eq: z.optional( z .int() .check( @@ -80910,7 +84141,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + start_epoch_ne: z.optional( z .int() .check( @@ -80918,7 +84149,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + start_epoch_lt: z.optional( z .int() .check( @@ -80926,7 +84157,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + start_epoch_lte: z.optional( z .int() .check( @@ -80934,7 +84165,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + start_epoch_gt: z.optional( z .int() .check( @@ -80942,7 +84173,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + start_epoch_gte: z.optional( z .int() .check( @@ -80950,7 +84181,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + start_epoch_between_min: z.optional( z .int() .check( @@ -80958,7 +84189,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + start_epoch_between_max_value: z.optional( z .int() .check( @@ -80966,9 +84197,9 @@ export const zFctValidatorBalanceServiceListData = 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+)*$/))), - epoch_eq: z.optional( + start_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + start_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + end_epoch_eq: z.optional( z .int() .check( @@ -80976,7 +84207,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_ne: z.optional( + end_epoch_ne: z.optional( z .int() .check( @@ -80984,7 +84215,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lt: z.optional( + end_epoch_lt: z.optional( z .int() .check( @@ -80992,7 +84223,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + end_epoch_lte: z.optional( z .int() .check( @@ -81000,7 +84231,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + end_epoch_gt: z.optional( z .int() .check( @@ -81008,7 +84239,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + end_epoch_gte: z.optional( z .int() .check( @@ -81016,7 +84247,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + end_epoch_between_min: z.optional( z .int() .check( @@ -81024,7 +84255,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + end_epoch_between_max_value: z.optional( z .int() .check( @@ -81032,9 +84263,9 @@ export const zFctValidatorBalanceServiceListData = z.object({ 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+)*$/))), - balance_eq: z.optional( + end_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + end_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + start_balance_eq: z.optional( z.coerce .bigint() .check( @@ -81044,7 +84275,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_ne: z.optional( + start_balance_ne: z.optional( z.coerce .bigint() .check( @@ -81054,7 +84285,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_lt: z.optional( + start_balance_lt: z.optional( z.coerce .bigint() .check( @@ -81064,7 +84295,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_lte: z.optional( + start_balance_lte: z.optional( z.coerce .bigint() .check( @@ -81074,7 +84305,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_gt: z.optional( + start_balance_gt: z.optional( z.coerce .bigint() .check( @@ -81084,7 +84315,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_gte: z.optional( + start_balance_gte: z.optional( z.coerce .bigint() .check( @@ -81094,7 +84325,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_between_min: z.optional( + start_balance_between_min: z.optional( z.coerce .bigint() .check( @@ -81104,7 +84335,7 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_between_max_value: z.optional( + start_balance_between_max_value: z.optional( z.coerce .bigint() .check( @@ -81114,8 +84345,254 @@ export const zFctValidatorBalanceServiceListData = z.object({ }) ) ), - balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + start_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + start_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_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', + }) + ) + ), + end_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + end_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_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', + }) + ) + ), + min_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_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', + }) + ) + ), + max_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), effective_balance_eq: z.optional( z.coerce .bigint() @@ -81226,9 +84703,9 @@ export const zFctValidatorBalanceServiceListData = z.object({ /** * OK */ -export const zFctValidatorBalanceServiceListResponse = zListFctValidatorBalanceResponse; +export const zFctValidatorBalanceDailyServiceListResponse = zListFctValidatorBalanceDailyResponse; -export const zFctValidatorBalanceServiceGetData = z.object({ +export const zFctValidatorBalanceDailyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ validator_index: z @@ -81244,9 +84721,9 @@ export const zFctValidatorBalanceServiceGetData = z.object({ /** * OK */ -export const zFctValidatorBalanceServiceGetResponse = zGetFctValidatorBalanceResponse; +export const zFctValidatorBalanceDailyServiceGetResponse = zGetFctValidatorBalanceDailyResponse; -export const zFctValidatorBalanceDailyServiceListData = z.object({ +export const zFctValidatorBalanceHourlyServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -81317,15 +84794,72 @@ export const zFctValidatorBalanceDailyServiceListData = z.object({ ), validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - day_start_date_eq: z.optional(z.string()), - day_start_date_ne: z.optional(z.string()), - day_start_date_contains: z.optional(z.string()), - day_start_date_starts_with: z.optional(z.string()), - day_start_date_ends_with: z.optional(z.string()), - day_start_date_like: z.optional(z.string()), - day_start_date_not_like: z.optional(z.string()), - day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_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' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -81962,17 +85496,214 @@ export const zFctValidatorBalanceDailyServiceListData = z.object({ /** * OK */ -export const zFctValidatorBalanceDailyServiceListResponse = zListFctValidatorBalanceDailyResponse; +export const zFctValidatorBalanceHourlyServiceListResponse = zListFctValidatorBalanceHourlyResponse; + +export const zFctValidatorBalanceHourlyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + validator_index: z + .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 zFctValidatorBalanceHourlyServiceGetResponse = zGetFctValidatorBalanceHourlyResponse; + +export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + entity_eq: z.optional(z.string()), + entity_ne: z.optional(z.string()), + entity_contains: z.optional(z.string()), + entity_starts_with: z.optional(z.string()), + entity_ends_with: z.optional(z.string()), + entity_like: z.optional(z.string()), + entity_not_like: z.optional(z.string()), + entity_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + entity_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + 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(/^[^,]+(,[^,]+)*$/))), + 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+)*$/))), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_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' }) + ) + ), + validator_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + validator_count_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 zFctValidatorCountByEntityByStatusDailyServiceListResponse = + zListFctValidatorCountByEntityByStatusDailyResponse; -export const zFctValidatorBalanceDailyServiceGetData = z.object({ +export const zFctValidatorCountByEntityByStatusDailyServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - validator_index: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ), + day_start_date: z.string(), }), query: z.optional(z.never()), }); @@ -81980,14 +85711,24 @@ export const zFctValidatorBalanceDailyServiceGetData = z.object({ /** * OK */ -export const zFctValidatorBalanceDailyServiceGetResponse = zGetFctValidatorBalanceDailyResponse; +export const zFctValidatorCountByEntityByStatusDailyServiceGetResponse = + zGetFctValidatorCountByEntityByStatusDailyResponse; -export const zFctValidatorBalanceHourlyServiceListData = z.object({ +export const zIntAddressFirstAccessServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - validator_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(/^[^,]+(,[^,]+)*$/))), + block_number_eq: z.optional( z .int() .check( @@ -81995,7 +85736,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_ne: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -82003,7 +85744,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_lt: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -82011,7 +85752,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_lte: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -82019,7 +85760,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_gt: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -82027,7 +85768,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_gte: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -82035,7 +85776,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_between_min: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -82043,7 +85784,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_between_max_value: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -82051,9 +85792,9 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - hour_start_date_time_eq: 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+)*$/))), + version_eq: z.optional( z .int() .check( @@ -82061,7 +85802,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_ne: z.optional( + version_ne: z.optional( z .int() .check( @@ -82069,7 +85810,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_lt: z.optional( + version_lt: z.optional( z .int() .check( @@ -82077,7 +85818,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_lte: z.optional( + version_lte: z.optional( z .int() .check( @@ -82085,7 +85826,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_gt: z.optional( + version_gt: z.optional( z .int() .check( @@ -82093,7 +85834,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_gte: z.optional( + version_gte: z.optional( z .int() .check( @@ -82101,7 +85842,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_between_min: z.optional( + version_between_min: z.optional( z .int() .check( @@ -82109,7 +85850,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_between_max_value: z.optional( + version_between_max_value: z.optional( z .int() .check( @@ -82117,17 +85858,55 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + version_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + version_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' }) ) ), - updated_date_time_ne: z.optional( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntAddressFirstAccessServiceListResponse = zListIntAddressFirstAccessResponse; + +export const zIntAddressFirstAccessServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + address: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntAddressFirstAccessServiceGetResponse = zGetIntAddressFirstAccessResponse; + +export const zIntAddressLastAccessServiceListData = 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( @@ -82135,7 +85914,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -82143,7 +85922,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -82151,7 +85930,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -82159,7 +85938,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -82167,7 +85946,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -82175,7 +85954,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -82183,9 +85962,7 @@ export const zFctValidatorBalanceHourlyServiceListData = 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+)*$/))), - start_epoch_eq: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -82193,15 +85970,64 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_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+)*$/))), + 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' }) ) ), - start_epoch_lt: z.optional( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntAddressLastAccessServiceListResponse = zListIntAddressLastAccessResponse; + +export const zIntAddressLastAccessServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + address: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntAddressLastAccessServiceGetResponse = zGetIntAddressLastAccessResponse; + +export const zIntAddressStorageSlotFirstAccessServiceListData = 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( @@ -82209,7 +86035,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_lte: z.optional( + block_number_ne: z.optional( z .int() .check( @@ -82217,7 +86043,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_gt: z.optional( + block_number_lt: z.optional( z .int() .check( @@ -82225,7 +86051,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_gte: z.optional( + block_number_lte: z.optional( z .int() .check( @@ -82233,7 +86059,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_between_min: z.optional( + block_number_gt: z.optional( z .int() .check( @@ -82241,7 +86067,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_between_max_value: z.optional( + block_number_gte: z.optional( z .int() .check( @@ -82249,9 +86075,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - start_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - start_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - end_epoch_eq: z.optional( + block_number_between_min: z.optional( z .int() .check( @@ -82259,7 +86083,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_ne: z.optional( + block_number_between_max_value: z.optional( z .int() .check( @@ -82267,7 +86091,18 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_lt: 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+)*$/))), + value_eq: z.optional(z.string()), + value_ne: z.optional(z.string()), + value_contains: z.optional(z.string()), + value_starts_with: z.optional(z.string()), + value_ends_with: z.optional(z.string()), + value_like: z.optional(z.string()), + value_not_like: z.optional(z.string()), + value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + version_eq: z.optional( z .int() .check( @@ -82275,7 +86110,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_lte: z.optional( + version_ne: z.optional( z .int() .check( @@ -82283,7 +86118,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_gt: z.optional( + version_lt: z.optional( z .int() .check( @@ -82291,7 +86126,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_gte: z.optional( + version_lte: z.optional( z .int() .check( @@ -82299,7 +86134,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_between_min: z.optional( + version_gt: z.optional( z .int() .check( @@ -82307,7 +86142,7 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_between_max_value: z.optional( + version_gte: z.optional( z .int() .check( @@ -82315,498 +86150,332 @@ export const zFctValidatorBalanceHourlyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - end_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - end_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_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', - }) - ) - ), - start_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - start_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - end_balance_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', - }) - ) - ), - end_balance_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', - }) - ) - ), - end_balance_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', - }) - ) - ), - end_balance_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', - }) - ) - ), - end_balance_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', - }) - ) - ), - end_balance_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', - }) - ) - ), - end_balance_between_min: z.optional( - z.coerce - .bigint() + version_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' }) ) ), - end_balance_between_max_value: z.optional( - z.coerce - .bigint() + version_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' }) ) ), - end_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - end_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - min_balance_eq: z.optional( - z.coerce - .bigint() + version_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + version_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: 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(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - min_balance_ne: z.optional( - z.coerce - .bigint() + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntAddressStorageSlotFirstAccessServiceListResponse = zListIntAddressStorageSlotFirstAccessResponse; + +export const zIntAddressStorageSlotFirstAccessServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + address: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntAddressStorageSlotFirstAccessServiceGetResponse = zGetIntAddressStorageSlotFirstAccessResponse; + +export const zIntAddressStorageSlotLastAccessServiceListData = 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( - 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' }) ) ), - min_balance_lt: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_lte: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_gt: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_gte: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_between_min: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_between_max_value: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - min_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - min_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_balance_eq: z.optional( - z.coerce - .bigint() + block_number_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' }) ) ), - max_balance_ne: 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+)*$/))), + value_eq: z.optional(z.string()), + value_ne: z.optional(z.string()), + value_contains: z.optional(z.string()), + value_starts_with: z.optional(z.string()), + value_ends_with: z.optional(z.string()), + value_like: z.optional(z.string()), + value_not_like: z.optional(z.string()), + value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + page_size: 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(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - max_balance_lt: z.optional( - z.coerce - .bigint() + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntAddressStorageSlotLastAccessServiceListResponse = zListIntAddressStorageSlotLastAccessResponse; + +export const zIntAddressStorageSlotLastAccessServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + address: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zIntAddressStorageSlotLastAccessServiceGetResponse = zGetIntAddressStorageSlotLastAccessResponse; + +export const zIntAttestationAttestedCanonicalServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + slot_start_date_time_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' }) ) ), - max_balance_lte: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - max_balance_gt: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - max_balance_gte: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - max_balance_between_min: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - max_balance_between_max_value: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - max_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - max_balance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_balance_eq: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - effective_balance_ne: z.optional( - z.coerce - .bigint() + slot_start_date_time_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' }) ) ), - effective_balance_lt: z.optional( - z.coerce - .bigint() + 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(/^[^,]+(,[^,]+)*$/))), + attesting_validator_index_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' }) ) ), - effective_balance_lte: z.optional( - z.coerce - .bigint() + attesting_validator_index_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' }) ) ), - effective_balance_gt: z.optional( - z.coerce - .bigint() + attesting_validator_index_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' }) ) ), - effective_balance_gte: z.optional( - z.coerce - .bigint() + attesting_validator_index_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' }) ) ), - effective_balance_between_min: z.optional( - z.coerce - .bigint() + attesting_validator_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' }) ) ), - effective_balance_between_max_value: z.optional( - z.coerce - .bigint() + attesting_validator_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' }) ) ), - effective_balance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - effective_balance_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(/^[^,]+(,[^,]+)*$/))), - slashed_eq: z.optional(z.boolean()), - slashed_ne: z.optional(z.boolean()), - page_size: z.optional( + attesting_validator_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' }) + 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 zFctValidatorBalanceHourlyServiceListResponse = zListFctValidatorBalanceHourlyResponse; - -export const zFctValidatorBalanceHourlyServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - validator_index: z - .int() - .check( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + attesting_validator_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' }) + ) ), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zFctValidatorBalanceHourlyServiceGetResponse = zGetFctValidatorBalanceHourlyResponse; - -export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - day_start_date_eq: z.optional(z.string()), - day_start_date_ne: z.optional(z.string()), - day_start_date_contains: z.optional(z.string()), - day_start_date_starts_with: z.optional(z.string()), - day_start_date_ends_with: z.optional(z.string()), - day_start_date_like: z.optional(z.string()), - day_start_date_not_like: z.optional(z.string()), - day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - entity_eq: z.optional(z.string()), - entity_ne: z.optional(z.string()), - entity_contains: z.optional(z.string()), - entity_starts_with: z.optional(z.string()), - entity_ends_with: z.optional(z.string()), - entity_like: z.optional(z.string()), - entity_not_like: z.optional(z.string()), - entity_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - entity_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - 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(/^[^,]+(,[^,]+)*$/))), + attesting_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + attesting_validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -82873,7 +86542,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = 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+)*$/))), - validator_count_eq: z.optional( + slot_eq: z.optional( z .int() .check( @@ -82881,7 +86550,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_ne: z.optional( + slot_ne: z.optional( z .int() .check( @@ -82889,7 +86558,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_lt: z.optional( + slot_lt: z.optional( z .int() .check( @@ -82897,7 +86566,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_lte: z.optional( + slot_lte: z.optional( z .int() .check( @@ -82905,7 +86574,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_gt: z.optional( + slot_gt: z.optional( z .int() .check( @@ -82913,7 +86582,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_gte: z.optional( + slot_gte: z.optional( z .int() .check( @@ -82921,7 +86590,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_between_min: z.optional( + slot_between_min: z.optional( z .int() .check( @@ -82929,7 +86598,7 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_between_max_value: z.optional( + slot_between_max_value: z.optional( z .int() .check( @@ -82937,57 +86606,17 @@ export const zFctValidatorCountByEntityByStatusDailyServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validator_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - validator_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: 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+)*$/))), + epoch_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 zFctValidatorCountByEntityByStatusDailyServiceListResponse = - zListFctValidatorCountByEntityByStatusDailyResponse; - -export const zFctValidatorCountByEntityByStatusDailyServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - day_start_date: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zFctValidatorCountByEntityByStatusDailyServiceGetResponse = - zGetFctValidatorCountByEntityByStatusDailyResponse; - -export const zIntAddressFirstAccessServiceListData = 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( + epoch_ne: z.optional( z .int() .check( @@ -82995,7 +86624,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + epoch_lt: z.optional( z .int() .check( @@ -83003,7 +86632,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + epoch_lte: z.optional( z .int() .check( @@ -83011,7 +86640,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + epoch_gt: z.optional( z .int() .check( @@ -83019,7 +86648,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + epoch_gte: z.optional( z .int() .check( @@ -83027,7 +86656,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + epoch_between_min: z.optional( z .int() .check( @@ -83035,7 +86664,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + epoch_between_max_value: z.optional( z .int() .check( @@ -83043,7 +86672,9 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: 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( @@ -83051,9 +86682,7 @@ export const zIntAddressFirstAccessServiceListData = 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+)*$/))), - version_eq: z.optional( + epoch_start_date_time_ne: z.optional( z .int() .check( @@ -83061,7 +86690,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_ne: z.optional( + epoch_start_date_time_lt: z.optional( z .int() .check( @@ -83069,7 +86698,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_lt: z.optional( + epoch_start_date_time_lte: z.optional( z .int() .check( @@ -83077,7 +86706,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_lte: z.optional( + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -83085,7 +86714,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_gt: z.optional( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -83093,7 +86722,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_gte: z.optional( + epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -83101,7 +86730,7 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_between_min: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -83109,7 +86738,9 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_between_max_value: 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+)*$/))), + source_epoch_eq: z.optional( z .int() .check( @@ -83117,55 +86748,15 @@ export const zIntAddressFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - version_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: z.optional( + source_epoch_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' }) - ) - ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntAddressFirstAccessServiceListResponse = zListIntAddressFirstAccessResponse; - -export const zIntAddressFirstAccessServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - address: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntAddressFirstAccessServiceGetResponse = zGetIntAddressFirstAccessResponse; - -export const zIntAddressLastAccessServiceListData = 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( + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + source_epoch_lt: z.optional( z .int() .check( @@ -83173,7 +86764,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + source_epoch_lte: z.optional( z .int() .check( @@ -83181,7 +86772,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + source_epoch_gt: z.optional( z .int() .check( @@ -83189,7 +86780,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + source_epoch_gte: z.optional( z .int() .check( @@ -83197,7 +86788,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + source_epoch_between_min: z.optional( z .int() .check( @@ -83205,7 +86796,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + source_epoch_between_max_value: z.optional( z .int() .check( @@ -83213,7 +86804,9 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + source_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + source_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + source_epoch_start_date_time_eq: z.optional( z .int() .check( @@ -83221,7 +86814,7 @@ export const zIntAddressLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + source_epoch_start_date_time_ne: z.optional( z .int() .check( @@ -83229,64 +86822,15 @@ export const zIntAddressLastAccessServiceListData = 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+)*$/))), - page_size: z.optional( + source_epoch_start_date_time_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' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntAddressLastAccessServiceListResponse = zListIntAddressLastAccessResponse; - -export const zIntAddressLastAccessServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - address: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntAddressLastAccessServiceGetResponse = zGetIntAddressLastAccessResponse; - -export const zIntAddressStorageSlotFirstAccessServiceListData = 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( + source_epoch_start_date_time_lte: z.optional( z .int() .check( @@ -83294,7 +86838,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + source_epoch_start_date_time_gt: z.optional( z .int() .check( @@ -83302,7 +86846,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + source_epoch_start_date_time_gte: z.optional( z .int() .check( @@ -83310,7 +86854,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + source_epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -83318,7 +86862,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + source_epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -83326,7 +86870,18 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + source_epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + source_epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + source_root_eq: z.optional(z.string()), + source_root_ne: z.optional(z.string()), + source_root_contains: z.optional(z.string()), + source_root_starts_with: z.optional(z.string()), + source_root_ends_with: z.optional(z.string()), + source_root_like: z.optional(z.string()), + source_root_not_like: z.optional(z.string()), + source_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + source_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + target_epoch_eq: z.optional( z .int() .check( @@ -83334,7 +86889,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + target_epoch_ne: z.optional( z .int() .check( @@ -83342,7 +86897,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + target_epoch_lt: z.optional( z .int() .check( @@ -83350,18 +86905,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = 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+)*$/))), - value_eq: z.optional(z.string()), - value_ne: z.optional(z.string()), - value_contains: z.optional(z.string()), - value_starts_with: z.optional(z.string()), - value_ends_with: z.optional(z.string()), - value_like: z.optional(z.string()), - value_not_like: z.optional(z.string()), - value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - version_eq: z.optional( + target_epoch_lte: z.optional( z .int() .check( @@ -83369,7 +86913,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_ne: z.optional( + target_epoch_gt: z.optional( z .int() .check( @@ -83377,7 +86921,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_lt: z.optional( + target_epoch_gte: z.optional( z .int() .check( @@ -83385,7 +86929,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_lte: z.optional( + target_epoch_between_min: z.optional( z .int() .check( @@ -83393,7 +86937,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_gt: z.optional( + target_epoch_between_max_value: z.optional( z .int() .check( @@ -83401,7 +86945,9 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_gte: z.optional( + target_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + target_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + target_epoch_start_date_time_eq: z.optional( z .int() .check( @@ -83409,7 +86955,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_between_min: z.optional( + target_epoch_start_date_time_ne: z.optional( z .int() .check( @@ -83417,7 +86963,7 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_between_max_value: z.optional( + target_epoch_start_date_time_lt: z.optional( z .int() .check( @@ -83425,64 +86971,15 @@ export const zIntAddressStorageSlotFirstAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - version_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - version_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - page_size: z.optional( + target_epoch_start_date_time_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' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntAddressStorageSlotFirstAccessServiceListResponse = zListIntAddressStorageSlotFirstAccessResponse; - -export const zIntAddressStorageSlotFirstAccessServiceGetData = z.object({ - body: z.optional(z.never()), - path: z.object({ - address: z.string(), - }), - query: z.optional(z.never()), -}); - -/** - * OK - */ -export const zIntAddressStorageSlotFirstAccessServiceGetResponse = zGetIntAddressStorageSlotFirstAccessResponse; - -export const zIntAddressStorageSlotLastAccessServiceListData = 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( + target_epoch_start_date_time_gt: z.optional( z .int() .check( @@ -83490,7 +86987,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_ne: z.optional( + target_epoch_start_date_time_gte: z.optional( z .int() .check( @@ -83498,7 +86995,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lt: z.optional( + target_epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -83506,7 +87003,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_lte: z.optional( + target_epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -83514,7 +87011,18 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gt: z.optional( + target_epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + target_epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + target_root_eq: z.optional(z.string()), + target_root_ne: z.optional(z.string()), + target_root_contains: z.optional(z.string()), + target_root_starts_with: z.optional(z.string()), + target_root_ends_with: z.optional(z.string()), + target_root_like: z.optional(z.string()), + target_root_not_like: z.optional(z.string()), + target_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + target_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + inclusion_distance_eq: z.optional( z .int() .check( @@ -83522,7 +87030,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + inclusion_distance_ne: z.optional( z .int() .check( @@ -83530,7 +87038,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + inclusion_distance_lt: z.optional( z .int() .check( @@ -83538,7 +87046,7 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + inclusion_distance_lte: z.optional( z .int() .check( @@ -83546,17 +87054,40 @@ export const zIntAddressStorageSlotLastAccessServiceListData = 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+)*$/))), - value_eq: z.optional(z.string()), - value_ne: z.optional(z.string()), - value_contains: z.optional(z.string()), - value_starts_with: z.optional(z.string()), - value_ends_with: z.optional(z.string()), - value_like: z.optional(z.string()), - value_not_like: z.optional(z.string()), - value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + inclusion_distance_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' }) + ) + ), + inclusion_distance_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' }) + ) + ), + inclusion_distance_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' }) + ) + ), + inclusion_distance_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' }) + ) + ), + inclusion_distance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + inclusion_distance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -83574,12 +87105,17 @@ export const zIntAddressStorageSlotLastAccessServiceListData = z.object({ /** * OK */ -export const zIntAddressStorageSlotLastAccessServiceListResponse = zListIntAddressStorageSlotLastAccessResponse; +export const zIntAttestationAttestedCanonicalServiceListResponse = zListIntAttestationAttestedCanonicalResponse; -export const zIntAddressStorageSlotLastAccessServiceGetData = z.object({ +export const zIntAttestationAttestedCanonicalServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - address: z.string(), + 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()), }); @@ -83587,9 +87123,9 @@ export const zIntAddressStorageSlotLastAccessServiceGetData = z.object({ /** * OK */ -export const zIntAddressStorageSlotLastAccessServiceGetResponse = zGetIntAddressStorageSlotLastAccessResponse; +export const zIntAttestationAttestedCanonicalServiceGetResponse = zGetIntAttestationAttestedCanonicalResponse; -export const zIntAttestationAttestedCanonicalServiceListData = z.object({ +export const zIntAttestationAttestedHeadServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -84281,7 +87817,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ target_root_not_like: z.optional(z.string()), target_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), target_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - inclusion_distance_eq: z.optional( + propagation_distance_eq: z.optional( z .int() .check( @@ -84289,7 +87825,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_ne: z.optional( + propagation_distance_ne: z.optional( z .int() .check( @@ -84297,7 +87833,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_lt: z.optional( + propagation_distance_lt: z.optional( z .int() .check( @@ -84305,7 +87841,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_lte: z.optional( + propagation_distance_lte: z.optional( z .int() .check( @@ -84313,7 +87849,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_gt: z.optional( + propagation_distance_gt: z.optional( z .int() .check( @@ -84321,7 +87857,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_gte: z.optional( + propagation_distance_gte: z.optional( z .int() .check( @@ -84329,7 +87865,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_between_min: z.optional( + propagation_distance_between_min: z.optional( z .int() .check( @@ -84337,7 +87873,7 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_between_max_value: z.optional( + propagation_distance_between_max_value: z.optional( z .int() .check( @@ -84345,8 +87881,8 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - inclusion_distance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - inclusion_distance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + propagation_distance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + propagation_distance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -84364,9 +87900,9 @@ export const zIntAttestationAttestedCanonicalServiceListData = z.object({ /** * OK */ -export const zIntAttestationAttestedCanonicalServiceListResponse = zListIntAttestationAttestedCanonicalResponse; +export const zIntAttestationAttestedHeadServiceListResponse = zListIntAttestationAttestedHeadResponse; -export const zIntAttestationAttestedCanonicalServiceGetData = z.object({ +export const zIntAttestationAttestedHeadServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -84382,9 +87918,9 @@ export const zIntAttestationAttestedCanonicalServiceGetData = z.object({ /** * OK */ -export const zIntAttestationAttestedCanonicalServiceGetResponse = zGetIntAttestationAttestedCanonicalResponse; +export const zIntAttestationAttestedHeadServiceGetResponse = zGetIntAttestationAttestedHeadResponse; -export const zIntAttestationAttestedHeadServiceListData = z.object({ +export const zIntAttestationFirstSeenServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -84455,15 +87991,6 @@ export const zIntAttestationAttestedHeadServiceListData = 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(/^[^,]+(,[^,]+)*$/))), attesting_validator_index_eq: z.optional( z .int() @@ -84480,7 +88007,206 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_lt: z.optional( + attesting_validator_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' }) + ) + ), + attesting_validator_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' }) + ) + ), + attesting_validator_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' }) + ) + ), + attesting_validator_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' }) + ) + ), + attesting_validator_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' }) + ) + ), + attesting_validator_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' }) + ) + ), + attesting_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + attesting_validator_index_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+)*$/))), + 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(/^[^,]+(,[^,]+)*$/))), + 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( @@ -84488,7 +88214,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_lte: z.optional( + epoch_lt: z.optional( z .int() .check( @@ -84496,7 +88222,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_gt: z.optional( + epoch_lte: z.optional( z .int() .check( @@ -84504,7 +88230,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_gte: z.optional( + epoch_gt: z.optional( z .int() .check( @@ -84512,7 +88238,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_between_min: z.optional( + epoch_gte: z.optional( z .int() .check( @@ -84520,7 +88246,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_between_max_value: z.optional( + epoch_between_min: z.optional( z .int() .check( @@ -84528,9 +88254,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - attesting_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - attesting_validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - updated_date_time_eq: z.optional( + epoch_between_max_value: z.optional( z .int() .check( @@ -84538,7 +88262,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: 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( @@ -84546,7 +88272,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + epoch_start_date_time_ne: z.optional( z .int() .check( @@ -84554,7 +88280,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + epoch_start_date_time_lt: z.optional( z .int() .check( @@ -84562,7 +88288,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + epoch_start_date_time_lte: z.optional( z .int() .check( @@ -84570,7 +88296,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -84578,7 +88304,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -84586,7 +88312,7 @@ export const zIntAttestationAttestedHeadServiceListData = 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_min: z.optional( z .int() .check( @@ -84594,9 +88320,7 @@ export const zIntAttestationAttestedHeadServiceListData = 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+)*$/))), - slot_eq: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -84604,7 +88328,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_ne: 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+)*$/))), + seen_slot_start_diff_eq: z.optional( z .int() .check( @@ -84612,7 +88338,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lt: z.optional( + seen_slot_start_diff_ne: z.optional( z .int() .check( @@ -84620,7 +88346,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lte: z.optional( + seen_slot_start_diff_lt: z.optional( z .int() .check( @@ -84628,7 +88354,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gt: z.optional( + seen_slot_start_diff_lte: z.optional( z .int() .check( @@ -84636,7 +88362,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gte: z.optional( + seen_slot_start_diff_gt: z.optional( z .int() .check( @@ -84644,7 +88370,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_min: z.optional( + seen_slot_start_diff_gte: z.optional( z .int() .check( @@ -84652,7 +88378,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_between_max_value: z.optional( + seen_slot_start_diff_between_min: z.optional( z .int() .check( @@ -84660,9 +88386,7 @@ export const zIntAttestationAttestedHeadServiceListData = 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+)*$/))), - epoch_eq: z.optional( + seen_slot_start_diff_between_max_value: z.optional( z .int() .check( @@ -84670,7 +88394,119 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_ne: z.optional( + seen_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + seen_slot_start_diff_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(/^[^,]+(,[^,]+)*$/))), + attesting_validator_committee_index_eq: z.optional(z.string()), + attesting_validator_committee_index_ne: z.optional(z.string()), + attesting_validator_committee_index_contains: z.optional(z.string()), + attesting_validator_committee_index_starts_with: z.optional(z.string()), + attesting_validator_committee_index_ends_with: z.optional(z.string()), + attesting_validator_committee_index_like: z.optional(z.string()), + attesting_validator_committee_index_not_like: z.optional(z.string()), + attesting_validator_committee_index_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + attesting_validator_committee_index_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + 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_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(/^[^,]+(,[^,]+)*$/))), + 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_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( @@ -84678,7 +88514,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lt: z.optional( + meta_client_geo_autonomous_system_number_ne: z.optional( z .int() .check( @@ -84686,7 +88522,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + meta_client_geo_autonomous_system_number_lt: z.optional( z .int() .check( @@ -84694,7 +88530,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + meta_client_geo_autonomous_system_number_lte: z.optional( z .int() .check( @@ -84702,7 +88538,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + meta_client_geo_autonomous_system_number_gt: z.optional( z .int() .check( @@ -84710,7 +88546,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + meta_client_geo_autonomous_system_number_gte: z.optional( z .int() .check( @@ -84718,7 +88554,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + meta_client_geo_autonomous_system_number_between_min: z.optional( z .int() .check( @@ -84726,9 +88562,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ 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( + meta_client_geo_autonomous_system_number_between_max_value: z.optional( z .int() .check( @@ -84736,15 +88570,82 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: 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_consensus_version_eq: z.optional(z.string()), + meta_consensus_version_ne: z.optional(z.string()), + meta_consensus_version_contains: z.optional(z.string()), + meta_consensus_version_starts_with: z.optional(z.string()), + meta_consensus_version_ends_with: z.optional(z.string()), + meta_consensus_version_like: z.optional(z.string()), + meta_consensus_version_not_like: z.optional(z.string()), + meta_consensus_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_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' }) ) ), - epoch_start_date_time_lt: z.optional( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntAttestationFirstSeenServiceListResponse = zListIntAttestationFirstSeenResponse; + +export const zIntAttestationFirstSeenServiceGetData = 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 zIntAttestationFirstSeenServiceGetResponse = zGetIntAttestationFirstSeenResponse; + +export const zIntBeaconCommitteeHeadServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + slot_start_date_time_eq: z.optional( z .int() .check( @@ -84752,7 +88653,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: z.optional( + slot_start_date_time_ne: z.optional( z .int() .check( @@ -84760,7 +88661,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + slot_start_date_time_lt: z.optional( z .int() .check( @@ -84768,7 +88669,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + slot_start_date_time_lte: z.optional( z .int() .check( @@ -84776,7 +88677,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + slot_start_date_time_gt: z.optional( z .int() .check( @@ -84784,7 +88685,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + slot_start_date_time_gte: z.optional( z .int() .check( @@ -84792,9 +88693,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ 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+)*$/))), - source_epoch_eq: z.optional( + slot_start_date_time_between_min: z.optional( z .int() .check( @@ -84802,7 +88701,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_ne: z.optional( + slot_start_date_time_between_max_value: z.optional( z .int() .check( @@ -84810,7 +88709,18 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_lt: 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+)*$/))), + committee_index_eq: z.optional(z.string()), + committee_index_ne: z.optional(z.string()), + committee_index_contains: z.optional(z.string()), + committee_index_starts_with: z.optional(z.string()), + committee_index_ends_with: z.optional(z.string()), + committee_index_like: z.optional(z.string()), + committee_index_not_like: z.optional(z.string()), + committee_index_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + committee_index_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -84818,7 +88728,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_lte: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -84826,7 +88736,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_gt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -84834,7 +88744,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_gte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -84842,7 +88752,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_between_min: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -84850,7 +88760,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_between_max_value: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -84858,9 +88768,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - source_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - source_epoch_start_date_time_eq: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -84868,7 +88776,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_ne: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -84876,7 +88784,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_lt: 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_eq: z.optional( z .int() .check( @@ -84884,7 +88794,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_lte: z.optional( + slot_ne: z.optional( z .int() .check( @@ -84892,7 +88802,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_gt: z.optional( + slot_lt: z.optional( z .int() .check( @@ -84900,7 +88810,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_gte: z.optional( + slot_lte: z.optional( z .int() .check( @@ -84908,7 +88818,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_between_min: z.optional( + slot_gt: z.optional( z .int() .check( @@ -84916,7 +88826,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_between_max_value: z.optional( + slot_gte: z.optional( z .int() .check( @@ -84924,18 +88834,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - source_epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - source_epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - source_root_eq: z.optional(z.string()), - source_root_ne: z.optional(z.string()), - source_root_contains: z.optional(z.string()), - source_root_starts_with: z.optional(z.string()), - source_root_ends_with: z.optional(z.string()), - source_root_like: z.optional(z.string()), - source_root_not_like: z.optional(z.string()), - source_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - source_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - target_epoch_eq: z.optional( + slot_between_min: z.optional( z .int() .check( @@ -84943,7 +88842,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_ne: z.optional( + slot_between_max_value: z.optional( z .int() .check( @@ -84951,7 +88850,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_lt: 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+)*$/))), + epoch_eq: z.optional( z .int() .check( @@ -84959,7 +88860,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_lte: z.optional( + epoch_ne: z.optional( z .int() .check( @@ -84967,7 +88868,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_gt: z.optional( + epoch_lt: z.optional( z .int() .check( @@ -84975,7 +88876,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_gte: z.optional( + epoch_lte: z.optional( z .int() .check( @@ -84983,7 +88884,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_between_min: z.optional( + epoch_gt: z.optional( z .int() .check( @@ -84991,7 +88892,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_between_max_value: z.optional( + epoch_gte: z.optional( z .int() .check( @@ -84999,9 +88900,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - target_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - target_epoch_start_date_time_eq: z.optional( + epoch_between_min: z.optional( z .int() .check( @@ -85009,7 +88908,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_ne: z.optional( + epoch_between_max_value: z.optional( z .int() .check( @@ -85017,7 +88916,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_lt: 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( @@ -85025,7 +88926,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_lte: z.optional( + epoch_start_date_time_ne: z.optional( z .int() .check( @@ -85033,7 +88934,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_gt: z.optional( + epoch_start_date_time_lt: z.optional( z .int() .check( @@ -85041,7 +88942,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_gte: z.optional( + epoch_start_date_time_lte: z.optional( z .int() .check( @@ -85049,7 +88950,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_between_min: z.optional( + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -85057,7 +88958,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_between_max_value: z.optional( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -85065,18 +88966,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - target_epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - target_epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - target_root_eq: z.optional(z.string()), - target_root_ne: z.optional(z.string()), - target_root_contains: z.optional(z.string()), - target_root_starts_with: z.optional(z.string()), - target_root_ends_with: z.optional(z.string()), - target_root_like: z.optional(z.string()), - target_root_not_like: z.optional(z.string()), - target_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - target_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - propagation_distance_eq: z.optional( + epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -85084,7 +88974,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_ne: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -85092,7 +88982,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_lt: 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+)*$/))), + validators_has: z.optional( z .int() .check( @@ -85100,7 +88992,27 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_lte: z.optional( + validators_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' }) + ) + ) + ), + validators_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' }) + ) + ) + ), + validators_length_eq: z.optional( z .int() .check( @@ -85108,7 +89020,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_gt: z.optional( + validators_length_gt: z.optional( z .int() .check( @@ -85116,7 +89028,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_gte: z.optional( + validators_length_gte: z.optional( z .int() .check( @@ -85124,7 +89036,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_between_min: z.optional( + validators_length_lt: z.optional( z .int() .check( @@ -85132,7 +89044,7 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_between_max_value: z.optional( + validators_length_lte: z.optional( z .int() .check( @@ -85140,8 +89052,6 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - propagation_distance_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - propagation_distance_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -85159,9 +89069,9 @@ export const zIntAttestationAttestedHeadServiceListData = z.object({ /** * OK */ -export const zIntAttestationAttestedHeadServiceListResponse = zListIntAttestationAttestedHeadResponse; +export const zIntBeaconCommitteeHeadServiceListResponse = zListIntBeaconCommitteeHeadResponse; -export const zIntAttestationAttestedHeadServiceGetData = z.object({ +export const zIntBeaconCommitteeHeadServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -85177,9 +89087,9 @@ export const zIntAttestationAttestedHeadServiceGetData = z.object({ /** * OK */ -export const zIntAttestationAttestedHeadServiceGetResponse = zGetIntAttestationAttestedHeadResponse; +export const zIntBeaconCommitteeHeadServiceGetResponse = zGetIntBeaconCommitteeHeadResponse; -export const zIntAttestationFirstSeenServiceListData = z.object({ +export const zIntBlockBlobCountCanonicalServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -85250,72 +89160,15 @@ export const zIntAttestationFirstSeenServiceListData = 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+)*$/))), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_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' }) - ) - ), - attesting_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - attesting_validator_index_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(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -85382,15 +89235,6 @@ export const zIntAttestationFirstSeenServiceListData = 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+)*$/))), - 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(/^[^,]+(,[^,]+)*$/))), slot_eq: z.optional( z .int() @@ -85589,183 +89433,7 @@ export const zIntAttestationFirstSeenServiceListData = 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+)*$/))), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_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' }) - ) - ), - seen_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - seen_slot_start_diff_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(/^[^,]+(,[^,]+)*$/))), - attesting_validator_committee_index_eq: z.optional(z.string()), - attesting_validator_committee_index_ne: z.optional(z.string()), - attesting_validator_committee_index_contains: z.optional(z.string()), - attesting_validator_committee_index_starts_with: z.optional(z.string()), - attesting_validator_committee_index_ends_with: z.optional(z.string()), - attesting_validator_committee_index_like: z.optional(z.string()), - attesting_validator_committee_index_not_like: z.optional(z.string()), - attesting_validator_committee_index_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - attesting_validator_committee_index_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - 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_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(/^[^,]+(,[^,]+)*$/))), - 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_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( + blob_count_eq: z.optional( z .int() .check( @@ -85773,7 +89441,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_ne: z.optional( + blob_count_ne: z.optional( z .int() .check( @@ -85781,7 +89449,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lt: z.optional( + blob_count_lt: z.optional( z .int() .check( @@ -85789,7 +89457,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_lte: z.optional( + blob_count_lte: z.optional( z .int() .check( @@ -85797,7 +89465,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gt: z.optional( + blob_count_gt: z.optional( z .int() .check( @@ -85805,7 +89473,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_gte: z.optional( + blob_count_gte: z.optional( z .int() .check( @@ -85813,7 +89481,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_min: z.optional( + blob_count_between_min: z.optional( z .int() .check( @@ -85821,7 +89489,7 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - meta_client_geo_autonomous_system_number_between_max_value: z.optional( + blob_count_between_max_value: z.optional( z .int() .check( @@ -85829,39 +89497,8 @@ export const zIntAttestationFirstSeenServiceListData = 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_consensus_version_eq: z.optional(z.string()), - meta_consensus_version_ne: z.optional(z.string()), - meta_consensus_version_contains: z.optional(z.string()), - meta_consensus_version_starts_with: z.optional(z.string()), - meta_consensus_version_ends_with: z.optional(z.string()), - meta_consensus_version_like: z.optional(z.string()), - meta_consensus_version_not_like: z.optional(z.string()), - meta_consensus_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_consensus_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_consensus_implementation_eq: z.optional(z.string()), - meta_consensus_implementation_ne: z.optional(z.string()), - meta_consensus_implementation_contains: z.optional(z.string()), - meta_consensus_implementation_starts_with: z.optional(z.string()), - meta_consensus_implementation_ends_with: z.optional(z.string()), - meta_consensus_implementation_like: z.optional(z.string()), - meta_consensus_implementation_not_like: z.optional(z.string()), - meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + 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+)*$/))), page_size: z.optional( z .int() @@ -85879,9 +89516,9 @@ export const zIntAttestationFirstSeenServiceListData = z.object({ /** * OK */ -export const zIntAttestationFirstSeenServiceListResponse = zListIntAttestationFirstSeenResponse; +export const zIntBlockBlobCountCanonicalServiceListResponse = zListIntBlockBlobCountCanonicalResponse; -export const zIntAttestationFirstSeenServiceGetData = z.object({ +export const zIntBlockBlobCountCanonicalServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -85897,9 +89534,9 @@ export const zIntAttestationFirstSeenServiceGetData = z.object({ /** * OK */ -export const zIntAttestationFirstSeenServiceGetResponse = zGetIntAttestationFirstSeenResponse; +export const zIntBlockBlobCountCanonicalServiceGetResponse = zGetIntBlockBlobCountCanonicalResponse; -export const zIntBeaconCommitteeHeadServiceListData = z.object({ +export const zIntBlockCanonicalServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -85970,15 +89607,15 @@ export const zIntBeaconCommitteeHeadServiceListData = 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+)*$/))), - committee_index_eq: z.optional(z.string()), - committee_index_ne: z.optional(z.string()), - committee_index_contains: z.optional(z.string()), - committee_index_starts_with: z.optional(z.string()), - committee_index_ends_with: z.optional(z.string()), - committee_index_like: z.optional(z.string()), - committee_index_not_like: z.optional(z.string()), - committee_index_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - committee_index_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(/^[^,]+(,[^,]+)*$/))), updated_date_time_eq: z.optional( z .int() @@ -86167,7 +89804,49 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + epoch_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' }) + ) + ), + 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( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_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' }) + ) + ), + epoch_start_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' }) + ) + ), + epoch_start_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' }) + ) + ), + epoch_start_date_time_gt: z.optional( z .int() .check( @@ -86175,9 +89854,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ 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( + epoch_start_date_time_gte: z.optional( z .int() .check( @@ -86185,7 +89862,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: z.optional( + epoch_start_date_time_between_min: z.optional( z .int() .check( @@ -86193,7 +89870,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lt: z.optional( + epoch_start_date_time_between_max_value: z.optional( z .int() .check( @@ -86201,7 +89878,18 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: 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_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(/^[^,]+(,[^,]+)*$/))), + block_total_bytes_eq: z.optional( z .int() .check( @@ -86209,7 +89897,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + block_total_bytes_ne: z.optional( z .int() .check( @@ -86217,7 +89905,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + block_total_bytes_lt: z.optional( z .int() .check( @@ -86225,7 +89913,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + block_total_bytes_lte: z.optional( z .int() .check( @@ -86233,7 +89921,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + block_total_bytes_gt: z.optional( z .int() .check( @@ -86241,9 +89929,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ 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+)*$/))), - validators_has: z.optional( + block_total_bytes_gte: z.optional( z .int() .check( @@ -86251,27 +89937,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validators_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' }) - ) - ) - ), - validators_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' }) - ) - ) - ), - validators_length_eq: z.optional( + block_total_bytes_between_min: z.optional( z .int() .check( @@ -86279,7 +89945,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validators_length_gt: z.optional( + block_total_bytes_between_max_value: z.optional( z .int() .check( @@ -86287,7 +89953,9 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validators_length_gte: 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( @@ -86295,7 +89963,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validators_length_lt: z.optional( + block_total_bytes_compressed_ne: z.optional( z .int() .check( @@ -86303,7 +89971,7 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - validators_length_lte: z.optional( + block_total_bytes_compressed_lt: z.optional( z .int() .check( @@ -86311,49 +89979,15 @@ export const zIntBeaconCommitteeHeadServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - page_size: z.optional( + block_total_bytes_compressed_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' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntBeaconCommitteeHeadServiceListResponse = zListIntBeaconCommitteeHeadResponse; - -export const zIntBeaconCommitteeHeadServiceGetData = 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 zIntBeaconCommitteeHeadServiceGetResponse = zGetIntBeaconCommitteeHeadResponse; - -export const zIntBlockBlobCountCanonicalServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - slot_start_date_time_eq: z.optional( + block_total_bytes_compressed_gt: z.optional( z .int() .check( @@ -86361,7 +89995,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_ne: z.optional( + block_total_bytes_compressed_gte: z.optional( z .int() .check( @@ -86369,7 +90003,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lt: z.optional( + block_total_bytes_compressed_between_min: z.optional( z .int() .check( @@ -86377,7 +90011,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lte: z.optional( + block_total_bytes_compressed_between_max_value: z.optional( z .int() .check( @@ -86385,7 +90019,27 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gt: z.optional( + 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+)*$/))), + parent_root_eq: z.optional(z.string()), + parent_root_ne: z.optional(z.string()), + parent_root_contains: z.optional(z.string()), + parent_root_starts_with: z.optional(z.string()), + parent_root_ends_with: z.optional(z.string()), + parent_root_like: z.optional(z.string()), + parent_root_not_like: z.optional(z.string()), + parent_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + parent_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + state_root_eq: z.optional(z.string()), + state_root_ne: z.optional(z.string()), + state_root_contains: z.optional(z.string()), + state_root_starts_with: z.optional(z.string()), + state_root_ends_with: z.optional(z.string()), + state_root_like: z.optional(z.string()), + state_root_not_like: z.optional(z.string()), + state_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + state_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_index_eq: z.optional( z .int() .check( @@ -86393,7 +90047,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gte: z.optional( + proposer_index_ne: z.optional( z .int() .check( @@ -86401,7 +90055,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_min: z.optional( + proposer_index_lt: z.optional( z .int() .check( @@ -86409,7 +90063,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_max_value: z.optional( + proposer_index_lte: z.optional( z .int() .check( @@ -86417,18 +90071,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = 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+)*$/))), - 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(/^[^,]+(,[^,]+)*$/))), - updated_date_time_eq: z.optional( + proposer_index_gt: z.optional( z .int() .check( @@ -86436,7 +90079,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + proposer_index_gte: z.optional( z .int() .check( @@ -86444,7 +90087,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + proposer_index_between_min: z.optional( z .int() .check( @@ -86452,7 +90095,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + proposer_index_between_max_value: z.optional( z .int() .check( @@ -86460,7 +90103,36 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + 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+)*$/))), + eth1_data_block_hash_eq: z.optional(z.string()), + eth1_data_block_hash_ne: z.optional(z.string()), + eth1_data_block_hash_contains: z.optional(z.string()), + eth1_data_block_hash_starts_with: z.optional(z.string()), + eth1_data_block_hash_ends_with: z.optional(z.string()), + eth1_data_block_hash_like: z.optional(z.string()), + eth1_data_block_hash_not_like: z.optional(z.string()), + eth1_data_block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + eth1_data_block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + eth1_data_deposit_root_eq: z.optional(z.string()), + eth1_data_deposit_root_ne: z.optional(z.string()), + eth1_data_deposit_root_contains: z.optional(z.string()), + eth1_data_deposit_root_starts_with: z.optional(z.string()), + eth1_data_deposit_root_ends_with: z.optional(z.string()), + eth1_data_deposit_root_like: z.optional(z.string()), + eth1_data_deposit_root_not_like: z.optional(z.string()), + eth1_data_deposit_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + eth1_data_deposit_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_block_hash_eq: z.optional(z.string()), + execution_payload_block_hash_ne: z.optional(z.string()), + execution_payload_block_hash_contains: z.optional(z.string()), + execution_payload_block_hash_starts_with: z.optional(z.string()), + execution_payload_block_hash_ends_with: z.optional(z.string()), + execution_payload_block_hash_like: z.optional(z.string()), + execution_payload_block_hash_not_like: z.optional(z.string()), + execution_payload_block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_block_number_eq: z.optional( z .int() .check( @@ -86468,7 +90140,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + execution_payload_block_number_ne: z.optional( z .int() .check( @@ -86476,7 +90148,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + execution_payload_block_number_lt: z.optional( z .int() .check( @@ -86484,7 +90156,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + execution_payload_block_number_lte: z.optional( z .int() .check( @@ -86492,9 +90164,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = 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+)*$/))), - slot_eq: z.optional( + execution_payload_block_number_gt: z.optional( z .int() .check( @@ -86502,7 +90172,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_ne: z.optional( + execution_payload_block_number_gte: z.optional( z .int() .check( @@ -86510,7 +90180,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lt: z.optional( + execution_payload_block_number_between_min: z.optional( z .int() .check( @@ -86518,7 +90188,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_lte: z.optional( + execution_payload_block_number_between_max_value: z.optional( z .int() .check( @@ -86526,41 +90196,373 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_gt: z.optional( - z - .int() + execution_payload_block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_fee_recipient_eq: z.optional(z.string()), + execution_payload_fee_recipient_ne: z.optional(z.string()), + execution_payload_fee_recipient_contains: z.optional(z.string()), + execution_payload_fee_recipient_starts_with: z.optional(z.string()), + execution_payload_fee_recipient_ends_with: z.optional(z.string()), + execution_payload_fee_recipient_like: z.optional(z.string()), + execution_payload_fee_recipient_not_like: z.optional(z.string()), + execution_payload_fee_recipient_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_fee_recipient_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_base_fee_per_gas_eq: z.optional(z.string()), + execution_payload_base_fee_per_gas_ne: z.optional(z.string()), + execution_payload_base_fee_per_gas_contains: z.optional(z.string()), + execution_payload_base_fee_per_gas_starts_with: z.optional(z.string()), + execution_payload_base_fee_per_gas_ends_with: z.optional(z.string()), + execution_payload_base_fee_per_gas_like: z.optional(z.string()), + execution_payload_base_fee_per_gas_not_like: z.optional(z.string()), + execution_payload_base_fee_per_gas_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_base_fee_per_gas_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_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', + }) + ) + ), + execution_payload_blob_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_blob_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_gas_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', + }) + ) + ), + execution_payload_excess_blob_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', + }) + ) + ), + execution_payload_excess_blob_gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_excess_blob_gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_gas_limit_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_gas_limit_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_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', + }) + ) + ), + execution_payload_gas_used_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', + }) ) ), - slot_gte: z.optional( - z - .int() + execution_payload_gas_used_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', + }) ) ), - slot_between_min: z.optional( - z - .int() + execution_payload_gas_used_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', + }) ) ), - slot_between_max_value: z.optional( - z - .int() + execution_payload_gas_used_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', + }) ) ), - 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( + execution_payload_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_state_root_eq: z.optional(z.string()), + execution_payload_state_root_ne: z.optional(z.string()), + execution_payload_state_root_contains: z.optional(z.string()), + execution_payload_state_root_starts_with: z.optional(z.string()), + execution_payload_state_root_ends_with: z.optional(z.string()), + execution_payload_state_root_like: z.optional(z.string()), + execution_payload_state_root_not_like: z.optional(z.string()), + execution_payload_state_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_state_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_parent_hash_eq: z.optional(z.string()), + execution_payload_parent_hash_ne: z.optional(z.string()), + execution_payload_parent_hash_contains: z.optional(z.string()), + execution_payload_parent_hash_starts_with: z.optional(z.string()), + execution_payload_parent_hash_ends_with: z.optional(z.string()), + execution_payload_parent_hash_like: z.optional(z.string()), + execution_payload_parent_hash_not_like: z.optional(z.string()), + execution_payload_parent_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_parent_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + execution_payload_transactions_count_eq: z.optional( z .int() .check( @@ -86568,7 +90570,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_ne: z.optional( + execution_payload_transactions_count_ne: z.optional( z .int() .check( @@ -86576,7 +90578,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lt: z.optional( + execution_payload_transactions_count_lt: z.optional( z .int() .check( @@ -86584,7 +90586,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + execution_payload_transactions_count_lte: z.optional( z .int() .check( @@ -86592,7 +90594,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + execution_payload_transactions_count_gt: z.optional( z .int() .check( @@ -86600,7 +90602,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + execution_payload_transactions_count_gte: z.optional( z .int() .check( @@ -86608,7 +90610,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + execution_payload_transactions_count_between_min: z.optional( z .int() .check( @@ -86616,7 +90618,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + execution_payload_transactions_count_between_max_value: z.optional( z .int() .check( @@ -86624,9 +90626,9 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ 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( + execution_payload_transactions_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_transactions_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_transactions_total_bytes_eq: z.optional( z .int() .check( @@ -86634,7 +90636,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: z.optional( + execution_payload_transactions_total_bytes_ne: z.optional( z .int() .check( @@ -86642,7 +90644,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lt: z.optional( + execution_payload_transactions_total_bytes_lt: z.optional( z .int() .check( @@ -86650,7 +90652,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: z.optional( + execution_payload_transactions_total_bytes_lte: z.optional( z .int() .check( @@ -86658,7 +90660,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + execution_payload_transactions_total_bytes_gt: z.optional( z .int() .check( @@ -86666,7 +90668,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + execution_payload_transactions_total_bytes_gte: z.optional( z .int() .check( @@ -86674,7 +90676,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + execution_payload_transactions_total_bytes_between_min: z.optional( z .int() .check( @@ -86682,7 +90684,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + execution_payload_transactions_total_bytes_between_max_value: z.optional( z .int() .check( @@ -86690,9 +90692,9 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ 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+)*$/))), - blob_count_eq: z.optional( + execution_payload_transactions_total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_transactions_total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + execution_payload_transactions_total_bytes_compressed_eq: z.optional( z .int() .check( @@ -86700,7 +90702,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_ne: z.optional( + execution_payload_transactions_total_bytes_compressed_ne: z.optional( z .int() .check( @@ -86708,7 +90710,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_lt: z.optional( + execution_payload_transactions_total_bytes_compressed_lt: z.optional( z .int() .check( @@ -86716,7 +90718,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_lte: z.optional( + execution_payload_transactions_total_bytes_compressed_lte: z.optional( z .int() .check( @@ -86724,7 +90726,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_gt: z.optional( + execution_payload_transactions_total_bytes_compressed_gt: z.optional( z .int() .check( @@ -86732,7 +90734,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_gte: z.optional( + execution_payload_transactions_total_bytes_compressed_gte: z.optional( z .int() .check( @@ -86740,7 +90742,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_between_min: z.optional( + execution_payload_transactions_total_bytes_compressed_between_min: z.optional( z .int() .check( @@ -86748,7 +90750,7 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - blob_count_between_max_value: z.optional( + execution_payload_transactions_total_bytes_compressed_between_max_value: z.optional( z .int() .check( @@ -86756,8 +90758,12 @@ export const zIntBlockBlobCountCanonicalServiceListData = 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+)*$/))), + execution_payload_transactions_total_bytes_compressed_in_values: z.optional( + z.string().check(z.regex(/^\d+(,\d+)*$/)) + ), + execution_payload_transactions_total_bytes_compressed_not_in_values: z.optional( + z.string().check(z.regex(/^\d+(,\d+)*$/)) + ), page_size: z.optional( z .int() @@ -86775,9 +90781,9 @@ export const zIntBlockBlobCountCanonicalServiceListData = z.object({ /** * OK */ -export const zIntBlockBlobCountCanonicalServiceListResponse = zListIntBlockBlobCountCanonicalResponse; +export const zIntBlockCanonicalServiceListResponse = zListIntBlockCanonicalResponse; -export const zIntBlockBlobCountCanonicalServiceGetData = z.object({ +export const zIntBlockCanonicalServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -86793,9 +90799,9 @@ export const zIntBlockBlobCountCanonicalServiceGetData = z.object({ /** * OK */ -export const zIntBlockBlobCountCanonicalServiceGetResponse = zGetIntBlockBlobCountCanonicalResponse; +export const zIntBlockCanonicalServiceGetResponse = zGetIntBlockCanonicalResponse; -export const zIntBlockCanonicalServiceListData = z.object({ +export const zIntBlockMevCanonicalServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -87139,425 +91145,157 @@ export const zIntBlockCanonicalServiceListData = 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_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(/^[^,]+(,[^,]+)*$/))), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - block_total_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' }) - ) - ), - 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( - z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), - z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) - ) - ), - block_total_bytes_compressed_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_total_bytes_compressed_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_total_bytes_compressed_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_total_bytes_compressed_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_total_bytes_compressed_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_total_bytes_compressed_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_total_bytes_compressed_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_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+)*$/))), - parent_root_eq: z.optional(z.string()), - parent_root_ne: z.optional(z.string()), - parent_root_contains: z.optional(z.string()), - parent_root_starts_with: z.optional(z.string()), - parent_root_ends_with: z.optional(z.string()), - parent_root_like: z.optional(z.string()), - parent_root_not_like: z.optional(z.string()), - parent_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - parent_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - state_root_eq: z.optional(z.string()), - state_root_ne: z.optional(z.string()), - state_root_contains: z.optional(z.string()), - state_root_starts_with: z.optional(z.string()), - state_root_ends_with: z.optional(z.string()), - state_root_like: z.optional(z.string()), - state_root_not_like: z.optional(z.string()), - state_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - state_root_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( - z - .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+)*$/))), - eth1_data_block_hash_eq: z.optional(z.string()), - eth1_data_block_hash_ne: z.optional(z.string()), - eth1_data_block_hash_contains: z.optional(z.string()), - eth1_data_block_hash_starts_with: z.optional(z.string()), - eth1_data_block_hash_ends_with: z.optional(z.string()), - eth1_data_block_hash_like: z.optional(z.string()), - eth1_data_block_hash_not_like: z.optional(z.string()), - eth1_data_block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - eth1_data_block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - eth1_data_deposit_root_eq: z.optional(z.string()), - eth1_data_deposit_root_ne: z.optional(z.string()), - eth1_data_deposit_root_contains: z.optional(z.string()), - eth1_data_deposit_root_starts_with: z.optional(z.string()), - eth1_data_deposit_root_ends_with: z.optional(z.string()), - eth1_data_deposit_root_like: z.optional(z.string()), - eth1_data_deposit_root_not_like: z.optional(z.string()), - eth1_data_deposit_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - eth1_data_deposit_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_block_hash_eq: z.optional(z.string()), - execution_payload_block_hash_ne: z.optional(z.string()), - execution_payload_block_hash_contains: z.optional(z.string()), - execution_payload_block_hash_starts_with: z.optional(z.string()), - execution_payload_block_hash_ends_with: z.optional(z.string()), - execution_payload_block_hash_like: z.optional(z.string()), - execution_payload_block_hash_not_like: z.optional(z.string()), - execution_payload_block_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_block_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_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' }) - ) - ), - execution_payload_block_number_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_block_number_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_fee_recipient_eq: z.optional(z.string()), - execution_payload_fee_recipient_ne: z.optional(z.string()), - execution_payload_fee_recipient_contains: z.optional(z.string()), - execution_payload_fee_recipient_starts_with: z.optional(z.string()), - execution_payload_fee_recipient_ends_with: z.optional(z.string()), - execution_payload_fee_recipient_like: z.optional(z.string()), - execution_payload_fee_recipient_not_like: z.optional(z.string()), - execution_payload_fee_recipient_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_fee_recipient_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_base_fee_per_gas_eq: z.optional(z.string()), - execution_payload_base_fee_per_gas_ne: z.optional(z.string()), - execution_payload_base_fee_per_gas_contains: z.optional(z.string()), - execution_payload_base_fee_per_gas_starts_with: z.optional(z.string()), - execution_payload_base_fee_per_gas_ends_with: z.optional(z.string()), - execution_payload_base_fee_per_gas_like: z.optional(z.string()), - execution_payload_base_fee_per_gas_not_like: z.optional(z.string()), - execution_payload_base_fee_per_gas_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_base_fee_per_gas_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_blob_gas_used_eq: z.optional( + earliest_bid_date_time_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', }) ) ), - execution_payload_blob_gas_used_ne: z.optional( + earliest_bid_date_time_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', }) ) ), - execution_payload_blob_gas_used_lt: z.optional( + earliest_bid_date_time_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', }) ) ), - execution_payload_blob_gas_used_lte: z.optional( + earliest_bid_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', }) ) ), - execution_payload_blob_gas_used_gt: z.optional( + earliest_bid_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', }) ) ), - execution_payload_blob_gas_used_gte: z.optional( + earliest_bid_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', }) ) ), - execution_payload_blob_gas_used_between_min: z.optional( + earliest_bid_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', }) ) ), - execution_payload_blob_gas_used_between_max_value: z.optional( + earliest_bid_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', }) ) ), - execution_payload_blob_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_blob_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_excess_blob_gas_eq: z.optional( + earliest_bid_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + earliest_bid_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), + relay_names_has: z.optional(z.string()), + relay_names_has_all_values: z.optional(z.array(z.string())), + relay_names_has_any_values: z.optional(z.array(z.string())), + relay_names_length_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' }) + ) + ), + relay_names_length_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' }) + ) + ), + relay_names_length_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' }) + ) + ), + relay_names_length_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' }) + ) + ), + relay_names_length_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' }) + ) + ), + 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(/^[^,]+(,[^,]+)*$/))), + block_number_eq: z.optional( z.coerce .bigint() .check( @@ -87567,7 +91305,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_ne: z.optional( + block_number_ne: z.optional( z.coerce .bigint() .check( @@ -87577,7 +91315,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_lt: z.optional( + block_number_lt: z.optional( z.coerce .bigint() .check( @@ -87587,7 +91325,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_lte: z.optional( + block_number_lte: z.optional( z.coerce .bigint() .check( @@ -87597,7 +91335,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_gt: z.optional( + block_number_gt: z.optional( z.coerce .bigint() .check( @@ -87607,7 +91345,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_gte: z.optional( + block_number_gte: z.optional( z.coerce .bigint() .check( @@ -87617,7 +91355,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_between_min: z.optional( + block_number_between_min: z.optional( z.coerce .bigint() .check( @@ -87627,7 +91365,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_between_max_value: z.optional( + block_number_between_max_value: z.optional( z.coerce .bigint() .check( @@ -87637,9 +91375,45 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_excess_blob_gas_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_excess_blob_gas_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_gas_limit_eq: 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+)*$/))), + 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(/^[^,]+(,[^,]+)*$/))), + builder_pubkey_eq: z.optional(z.string()), + builder_pubkey_ne: z.optional(z.string()), + builder_pubkey_contains: z.optional(z.string()), + builder_pubkey_starts_with: z.optional(z.string()), + builder_pubkey_ends_with: z.optional(z.string()), + builder_pubkey_like: z.optional(z.string()), + builder_pubkey_not_like: z.optional(z.string()), + builder_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + builder_pubkey_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_pubkey_eq: z.optional(z.string()), + proposer_pubkey_ne: z.optional(z.string()), + proposer_pubkey_contains: z.optional(z.string()), + proposer_pubkey_starts_with: z.optional(z.string()), + proposer_pubkey_ends_with: z.optional(z.string()), + proposer_pubkey_like: z.optional(z.string()), + proposer_pubkey_not_like: z.optional(z.string()), + proposer_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_pubkey_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_fee_recipient_eq: z.optional(z.string()), + proposer_fee_recipient_ne: z.optional(z.string()), + proposer_fee_recipient_contains: z.optional(z.string()), + proposer_fee_recipient_starts_with: z.optional(z.string()), + proposer_fee_recipient_ends_with: z.optional(z.string()), + proposer_fee_recipient_like: z.optional(z.string()), + proposer_fee_recipient_not_like: z.optional(z.string()), + proposer_fee_recipient_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_fee_recipient_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + gas_limit_eq: z.optional( z.coerce .bigint() .check( @@ -87649,7 +91423,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_ne: z.optional( + gas_limit_ne: z.optional( z.coerce .bigint() .check( @@ -87659,7 +91433,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_lt: z.optional( + gas_limit_lt: z.optional( z.coerce .bigint() .check( @@ -87669,7 +91443,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_lte: z.optional( + gas_limit_lte: z.optional( z.coerce .bigint() .check( @@ -87679,7 +91453,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_gt: z.optional( + gas_limit_gt: z.optional( z.coerce .bigint() .check( @@ -87689,7 +91463,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_gte: z.optional( + gas_limit_gte: z.optional( z.coerce .bigint() .check( @@ -87699,7 +91473,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_between_min: z.optional( + gas_limit_between_min: z.optional( z.coerce .bigint() .check( @@ -87709,7 +91483,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_between_max_value: z.optional( + gas_limit_between_max_value: z.optional( z.coerce .bigint() .check( @@ -87719,9 +91493,9 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_limit_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_gas_limit_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_gas_used_eq: z.optional( + 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+)*$/))), + gas_used_eq: z.optional( z.coerce .bigint() .check( @@ -87731,7 +91505,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_ne: z.optional( + gas_used_ne: z.optional( z.coerce .bigint() .check( @@ -87741,7 +91515,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_lt: z.optional( + gas_used_lt: z.optional( z.coerce .bigint() .check( @@ -87751,7 +91525,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_lte: z.optional( + gas_used_lte: z.optional( z.coerce .bigint() .check( @@ -87761,7 +91535,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_gt: z.optional( + gas_used_gt: z.optional( z.coerce .bigint() .check( @@ -87771,7 +91545,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_gte: z.optional( + gas_used_gte: z.optional( z.coerce .bigint() .check( @@ -87781,7 +91555,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_between_min: z.optional( + gas_used_between_min: z.optional( z.coerce .bigint() .check( @@ -87791,7 +91565,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_between_max_value: z.optional( + gas_used_between_max_value: z.optional( z.coerce .bigint() .check( @@ -87801,159 +91575,18 @@ export const zIntBlockCanonicalServiceListData = z.object({ }) ) ), - execution_payload_gas_used_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_gas_used_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_state_root_eq: z.optional(z.string()), - execution_payload_state_root_ne: z.optional(z.string()), - execution_payload_state_root_contains: z.optional(z.string()), - execution_payload_state_root_starts_with: z.optional(z.string()), - execution_payload_state_root_ends_with: z.optional(z.string()), - execution_payload_state_root_like: z.optional(z.string()), - execution_payload_state_root_not_like: z.optional(z.string()), - execution_payload_state_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_state_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_parent_hash_eq: z.optional(z.string()), - execution_payload_parent_hash_ne: z.optional(z.string()), - execution_payload_parent_hash_contains: z.optional(z.string()), - execution_payload_parent_hash_starts_with: z.optional(z.string()), - execution_payload_parent_hash_ends_with: z.optional(z.string()), - execution_payload_parent_hash_like: z.optional(z.string()), - execution_payload_parent_hash_not_like: z.optional(z.string()), - execution_payload_parent_hash_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_parent_hash_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_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' }) - ) - ), - execution_payload_transactions_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_transactions_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_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' }) - ) - ), - execution_payload_transactions_total_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_transactions_total_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - execution_payload_transactions_total_bytes_compressed_eq: z.optional( + 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+)*$/))), + value_eq: z.optional(z.string()), + value_ne: z.optional(z.string()), + value_contains: z.optional(z.string()), + value_starts_with: z.optional(z.string()), + value_ends_with: z.optional(z.string()), + value_like: z.optional(z.string()), + value_not_like: z.optional(z.string()), + value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + transaction_count_eq: z.optional( z .int() .check( @@ -87961,7 +91594,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_ne: z.optional( + transaction_count_ne: z.optional( z .int() .check( @@ -87969,7 +91602,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_lt: z.optional( + transaction_count_lt: z.optional( z .int() .check( @@ -87977,7 +91610,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_lte: z.optional( + transaction_count_lte: z.optional( z .int() .check( @@ -87985,7 +91618,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_gt: z.optional( + transaction_count_gt: z.optional( z .int() .check( @@ -87993,7 +91626,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_gte: z.optional( + transaction_count_gte: z.optional( z .int() .check( @@ -88001,7 +91634,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_between_min: z.optional( + transaction_count_between_min: z.optional( z .int() .check( @@ -88009,7 +91642,7 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_between_max_value: z.optional( + transaction_count_between_max_value: z.optional( z .int() .check( @@ -88017,12 +91650,8 @@ export const zIntBlockCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - execution_payload_transactions_total_bytes_compressed_in_values: z.optional( - z.string().check(z.regex(/^\d+(,\d+)*$/)) - ), - execution_payload_transactions_total_bytes_compressed_not_in_values: z.optional( - z.string().check(z.regex(/^\d+(,\d+)*$/)) - ), + transaction_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -88040,9 +91669,9 @@ export const zIntBlockCanonicalServiceListData = z.object({ /** * OK */ -export const zIntBlockCanonicalServiceListResponse = zListIntBlockCanonicalResponse; +export const zIntBlockMevCanonicalServiceListResponse = zListIntBlockMevCanonicalResponse; -export const zIntBlockCanonicalServiceGetData = z.object({ +export const zIntBlockMevCanonicalServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -88058,88 +91687,113 @@ export const zIntBlockCanonicalServiceGetData = z.object({ /** * OK */ -export const zIntBlockCanonicalServiceGetResponse = zGetIntBlockCanonicalResponse; +export const zIntBlockMevCanonicalServiceGetResponse = zGetIntBlockMevCanonicalResponse; -export const zIntBlockMevCanonicalServiceListData = z.object({ +export const zIntBlockOpcodeGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( z.object({ - slot_start_date_time_eq: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_ne: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_lt: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_lte: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_gt: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_gte: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_between_min: z.optional( - z - .int() + block_number_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', + }) ) ), - slot_start_date_time_between_max_value: z.optional( - z - .int() + block_number_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', + }) ) ), - 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_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+)*$/))), + 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() @@ -88206,89 +91860,297 @@ export const zIntBlockMevCanonicalServiceListData = 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_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - slot_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', + }) ) ), - 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() + 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', + }) ) ), - epoch_ne: z.optional( + gas_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_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_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_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_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_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_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+)*$/))), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + error_count_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', + }) + ) + ), + 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+)*$/))), + 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' }) ) ), - epoch_lt: z.optional( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntBlockOpcodeGasServiceListResponse = zListIntBlockOpcodeGasResponse; + +export const zIntBlockOpcodeGasServiceGetData = 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 zIntBlockOpcodeGasServiceGetResponse = zGetIntBlockOpcodeGasResponse; + +export const zIntBlockProposerCanonicalServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + slot_start_date_time_eq: z.optional( z .int() .check( @@ -88296,7 +92158,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + slot_start_date_time_ne: z.optional( z .int() .check( @@ -88304,7 +92166,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + slot_start_date_time_lt: z.optional( z .int() .check( @@ -88312,7 +92174,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + slot_start_date_time_lte: z.optional( z .int() .check( @@ -88320,7 +92182,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + slot_start_date_time_gt: z.optional( z .int() .check( @@ -88328,7 +92190,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( + slot_start_date_time_gte: z.optional( z .int() .check( @@ -88336,9 +92198,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ 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( + slot_start_date_time_between_min: z.optional( z .int() .check( @@ -88346,7 +92206,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_ne: z.optional( + slot_start_date_time_between_max_value: z.optional( z .int() .check( @@ -88354,7 +92214,9 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lt: 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+)*$/))), + updated_date_time_eq: z.optional( z .int() .check( @@ -88362,7 +92224,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_lte: z.optional( + updated_date_time_ne: z.optional( z .int() .check( @@ -88370,7 +92232,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gt: z.optional( + updated_date_time_lt: z.optional( z .int() .check( @@ -88378,7 +92240,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_gte: z.optional( + updated_date_time_lte: z.optional( z .int() .check( @@ -88386,7 +92248,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_min: z.optional( + updated_date_time_gt: z.optional( z .int() .check( @@ -88394,7 +92256,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_start_date_time_between_max_value: z.optional( + updated_date_time_gte: z.optional( z .int() .check( @@ -88402,110 +92264,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ 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+)*$/))), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_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', - }) - ) - ), - earliest_bid_date_time_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - earliest_bid_date_time_not_in_values: z.optional(z.string().check(z.regex(/^-?\d+(,-?\d+)*$/))), - relay_names_has: z.optional(z.string()), - relay_names_has_all_values: z.optional(z.array(z.string())), - relay_names_has_any_values: z.optional(z.array(z.string())), - relay_names_length_eq: z.optional( + updated_date_time_between_min: z.optional( z .int() .check( @@ -88513,7 +92272,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - relay_names_length_gt: z.optional( + updated_date_time_between_max_value: z.optional( z .int() .check( @@ -88521,7 +92280,9 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - relay_names_length_gte: 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_eq: z.optional( z .int() .check( @@ -88529,7 +92290,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - relay_names_length_lt: z.optional( + slot_ne: z.optional( z .int() .check( @@ -88537,7 +92298,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - relay_names_length_lte: z.optional( + slot_lt: z.optional( z .int() .check( @@ -88545,307 +92306,181 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - 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(/^[^,]+(,[^,]+)*$/))), - 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', - }) + 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' }) ) ), - block_number_gt: z.optional( - z.coerce - .bigint() + slot_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() + slot_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() + slot_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() + slot_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+)*$/))), - 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(/^[^,]+(,[^,]+)*$/))), - builder_pubkey_eq: z.optional(z.string()), - builder_pubkey_ne: z.optional(z.string()), - builder_pubkey_contains: z.optional(z.string()), - builder_pubkey_starts_with: z.optional(z.string()), - builder_pubkey_ends_with: z.optional(z.string()), - builder_pubkey_like: z.optional(z.string()), - builder_pubkey_not_like: z.optional(z.string()), - builder_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - builder_pubkey_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_pubkey_eq: z.optional(z.string()), - proposer_pubkey_ne: z.optional(z.string()), - proposer_pubkey_contains: z.optional(z.string()), - proposer_pubkey_starts_with: z.optional(z.string()), - proposer_pubkey_ends_with: z.optional(z.string()), - proposer_pubkey_like: z.optional(z.string()), - proposer_pubkey_not_like: z.optional(z.string()), - proposer_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_pubkey_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_fee_recipient_eq: z.optional(z.string()), - proposer_fee_recipient_ne: z.optional(z.string()), - proposer_fee_recipient_contains: z.optional(z.string()), - proposer_fee_recipient_starts_with: z.optional(z.string()), - proposer_fee_recipient_ends_with: z.optional(z.string()), - proposer_fee_recipient_like: z.optional(z.string()), - proposer_fee_recipient_not_like: z.optional(z.string()), - proposer_fee_recipient_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_fee_recipient_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - gas_limit_eq: z.optional( - z.coerce - .bigint() + 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(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_ne: z.optional( - z.coerce - .bigint() + epoch_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' }) ) ), - gas_limit_lt: z.optional( - z.coerce - .bigint() + epoch_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' }) ) ), - gas_limit_lte: z.optional( - z.coerce - .bigint() + epoch_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' }) ) ), - gas_limit_gt: z.optional( - z.coerce - .bigint() + epoch_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_gte: z.optional( - z.coerce - .bigint() + epoch_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_min: z.optional( - z.coerce - .bigint() + epoch_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_between_max_value: z.optional( - z.coerce - .bigint() + epoch_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' }) ) ), - 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+)*$/))), - gas_used_eq: z.optional( - z.coerce - .bigint() + 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( - 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_used_ne: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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' }) ) ), - gas_used_lt: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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' }) ) ), - gas_used_lte: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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' }) ) ), - gas_used_gt: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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_used_gte: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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_used_between_min: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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_used_between_max_value: z.optional( - z.coerce - .bigint() + epoch_start_date_time_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' }) ) ), - 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+)*$/))), - value_eq: z.optional(z.string()), - value_ne: z.optional(z.string()), - value_contains: z.optional(z.string()), - value_starts_with: z.optional(z.string()), - value_ends_with: z.optional(z.string()), - value_like: z.optional(z.string()), - value_not_like: z.optional(z.string()), - value_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - value_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - transaction_count_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+)*$/))), + proposer_validator_index_eq: z.optional( z .int() .check( @@ -88853,7 +92488,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_ne: z.optional( + proposer_validator_index_ne: z.optional( z .int() .check( @@ -88861,7 +92496,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_lt: z.optional( + proposer_validator_index_lt: z.optional( z .int() .check( @@ -88869,7 +92504,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_lte: z.optional( + proposer_validator_index_lte: z.optional( z .int() .check( @@ -88877,7 +92512,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_gt: z.optional( + proposer_validator_index_gt: z.optional( z .int() .check( @@ -88885,7 +92520,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_gte: z.optional( + proposer_validator_index_gte: z.optional( z .int() .check( @@ -88893,7 +92528,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_between_min: z.optional( + proposer_validator_index_between_min: z.optional( z .int() .check( @@ -88901,7 +92536,7 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_between_max_value: z.optional( + proposer_validator_index_between_max_value: z.optional( z .int() .check( @@ -88909,8 +92544,26 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - transaction_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - transaction_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + proposer_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + proposer_validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + proposer_pubkey_eq: z.optional(z.string()), + proposer_pubkey_ne: z.optional(z.string()), + proposer_pubkey_contains: z.optional(z.string()), + proposer_pubkey_starts_with: z.optional(z.string()), + proposer_pubkey_ends_with: z.optional(z.string()), + proposer_pubkey_like: z.optional(z.string()), + proposer_pubkey_not_like: z.optional(z.string()), + proposer_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + proposer_pubkey_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(/^[^,]+(,[^,]+)*$/))), page_size: z.optional( z .int() @@ -88928,9 +92581,9 @@ export const zIntBlockMevCanonicalServiceListData = z.object({ /** * OK */ -export const zIntBlockMevCanonicalServiceListResponse = zListIntBlockMevCanonicalResponse; +export const zIntBlockProposerCanonicalServiceListResponse = zListIntBlockProposerCanonicalResponse; -export const zIntBlockMevCanonicalServiceGetData = z.object({ +export const zIntBlockProposerCanonicalServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ slot_start_date_time: z @@ -88946,9 +92599,9 @@ export const zIntBlockMevCanonicalServiceGetData = z.object({ /** * OK */ -export const zIntBlockMevCanonicalServiceGetResponse = zGetIntBlockMevCanonicalResponse; +export const zIntBlockProposerCanonicalServiceGetResponse = zGetIntBlockProposerCanonicalResponse; -export const zIntBlockOpcodeGasServiceListData = z.object({ +export const zIntBlockReceiptSizeServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -89035,15 +92688,6 @@ export const zIntBlockOpcodeGasServiceListData = 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+)*$/))), - 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()), @@ -89087,203 +92731,39 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ ), 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+)*$/))), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - 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('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - gas_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_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_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_gt: z.optional( - z.coerce - .bigint() + .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_gte: z.optional( - z.coerce - .bigint() + updated_date_time_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_between_min: z.optional( - z.coerce - .bigint() + updated_date_time_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_between_max_value: z.optional( - z.coerce - .bigint() + updated_date_time_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' }) ) ), - 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+)*$/))), - error_count_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+)*$/))), + receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -89293,7 +92773,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_ne: z.optional( + receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -89303,7 +92783,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_lt: z.optional( + receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -89313,7 +92793,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_lte: z.optional( + receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -89323,7 +92803,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_gt: z.optional( + receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -89333,7 +92813,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_gte: z.optional( + receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -89343,7 +92823,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_between_min: z.optional( + receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -89353,7 +92833,7 @@ export const zIntBlockOpcodeGasServiceListData = z.object({ }) ) ), - error_count_between_max_value: z.optional( + receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -89363,53 +92843,17 @@ export const zIntBlockOpcodeGasServiceListData = 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+)*$/))), - page_size: z.optional( + receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_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' }) ) ), - page_token: z.optional(z.string()), - order_by: z.optional(z.string()), - }) - ), -}); - -/** - * OK - */ -export const zIntBlockOpcodeGasServiceListResponse = zListIntBlockOpcodeGasResponse; - -export const zIntBlockOpcodeGasServiceGetData = 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 zIntBlockOpcodeGasServiceGetResponse = zGetIntBlockOpcodeGasResponse; - -export const zIntBlockProposerCanonicalServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - slot_start_date_time_eq: z.optional( + transaction_count_ne: z.optional( z .int() .check( @@ -89417,7 +92861,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_ne: z.optional( + transaction_count_lt: z.optional( z .int() .check( @@ -89425,7 +92869,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lt: z.optional( + transaction_count_lte: z.optional( z .int() .check( @@ -89433,7 +92877,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_lte: z.optional( + transaction_count_gt: z.optional( z .int() .check( @@ -89441,7 +92885,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gt: z.optional( + transaction_count_gte: z.optional( z .int() .check( @@ -89449,7 +92893,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_gte: z.optional( + transaction_count_between_min: z.optional( z .int() .check( @@ -89457,7 +92901,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_min: z.optional( + transaction_count_between_max_value: z.optional( z .int() .check( @@ -89465,7 +92909,9 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - slot_start_date_time_between_max_value: z.optional( + transaction_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + transaction_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_count_eq: z.optional( z .int() .check( @@ -89473,9 +92919,7 @@ export const zIntBlockProposerCanonicalServiceListData = 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+)*$/))), - updated_date_time_eq: z.optional( + log_count_ne: z.optional( z .int() .check( @@ -89483,7 +92927,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + log_count_lt: z.optional( z .int() .check( @@ -89491,7 +92935,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + log_count_lte: z.optional( z .int() .check( @@ -89499,7 +92943,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + log_count_gt: z.optional( z .int() .check( @@ -89507,7 +92951,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + log_count_gte: z.optional( z .int() .check( @@ -89515,7 +92959,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + log_count_between_min: z.optional( z .int() .check( @@ -89523,7 +92967,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + log_count_between_max_value: z.optional( z .int() .check( @@ -89531,73 +92975,91 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( - z - .int() + log_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_data_bytes_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', + }) ) ), - 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_eq: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_ne: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_lt: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_lte: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_gt: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_gte: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_between_min: z.optional( - z - .int() + log_data_bytes_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', + }) ) ), - slot_between_max_value: z.optional( + log_data_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_data_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_topic_count_eq: z.optional( z .int() .check( @@ -89605,9 +93067,7 @@ export const zIntBlockProposerCanonicalServiceListData = 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+)*$/))), - epoch_eq: z.optional( + log_topic_count_ne: z.optional( z .int() .check( @@ -89615,7 +93075,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_ne: z.optional( + log_topic_count_lt: z.optional( z .int() .check( @@ -89623,7 +93083,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lt: z.optional( + log_topic_count_lte: z.optional( z .int() .check( @@ -89631,7 +93091,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_lte: z.optional( + log_topic_count_gt: z.optional( z .int() .check( @@ -89639,7 +93099,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gt: z.optional( + log_topic_count_gte: z.optional( z .int() .check( @@ -89647,7 +93107,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_gte: z.optional( + log_topic_count_between_min: z.optional( z .int() .check( @@ -89655,7 +93115,7 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_min: z.optional( + log_topic_count_between_max_value: z.optional( z .int() .check( @@ -89663,166 +93123,255 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - epoch_between_max_value: z.optional( - z - .int() + log_topic_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_topic_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_receipt_bytes_per_transaction_value: z.optional(z.number()), + max_receipt_bytes_per_transaction_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', + }) ) ), - 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() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_ne: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_lt: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_lte: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_gt: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_gte: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_between_min: z.optional( - z - .int() + max_receipt_bytes_per_transaction_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', + }) ) ), - epoch_start_date_time_between_max_value: z.optional( - z - .int() + max_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_transaction_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', + }) ) ), - 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+)*$/))), - proposer_validator_index_eq: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_ne: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_lt: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_lte: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_gt: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_gte: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_between_min: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_between_max_value: z.optional( - z - .int() + p50_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_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', + }) ) ), - proposer_validator_index_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - proposer_validator_index_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), - proposer_pubkey_eq: z.optional(z.string()), - proposer_pubkey_ne: z.optional(z.string()), - proposer_pubkey_contains: z.optional(z.string()), - proposer_pubkey_starts_with: z.optional(z.string()), - proposer_pubkey_ends_with: z.optional(z.string()), - proposer_pubkey_like: z.optional(z.string()), - proposer_pubkey_not_like: z.optional(z.string()), - proposer_pubkey_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), - proposer_pubkey_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(/^[^,]+(,[^,]+)*$/))), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_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', + }) + ) + ), + p95_receipt_bytes_per_transaction_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_receipt_bytes_per_transaction_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -89840,16 +93389,18 @@ export const zIntBlockProposerCanonicalServiceListData = z.object({ /** * OK */ -export const zIntBlockProposerCanonicalServiceListResponse = zListIntBlockProposerCanonicalResponse; +export const zIntBlockReceiptSizeServiceListResponse = zListIntBlockReceiptSizeResponse; -export const zIntBlockProposerCanonicalServiceGetData = z.object({ +export const zIntBlockReceiptSizeServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - slot_start_date_time: z - .int() + block_number: 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', + }) ), }), query: z.optional(z.never()), @@ -89858,7 +93409,7 @@ export const zIntBlockProposerCanonicalServiceGetData = z.object({ /** * OK */ -export const zIntBlockProposerCanonicalServiceGetResponse = zGetIntBlockProposerCanonicalResponse; +export const zIntBlockReceiptSizeServiceGetResponse = zGetIntBlockReceiptSizeResponse; export const zIntBlockResourceGasServiceListData = z.object({ body: z.optional(z.never()), @@ -107489,7 +111040,331 @@ 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( + 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( + 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(/^[^,]+(,[^,]+)*$/))), + 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+)*$/))), + effective_bytes_eq: z.optional( z .int() .check( @@ -107497,7 +111372,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( @@ -107505,7 +111380,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( @@ -107513,7 +111388,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( @@ -107521,7 +111396,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( @@ -107529,7 +111404,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( @@ -107537,7 +111412,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( @@ -107545,7 +111420,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( @@ -107553,8 +111428,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() @@ -107572,9 +111447,9 @@ export const zIntStorageSlotNextTouchServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotNextTouchServiceListResponse = zListIntStorageSlotNextTouchResponse; +export const zIntStorageSlotReactivation1mServiceListResponse = zListIntStorageSlotReactivation1mResponse; -export const zIntStorageSlotNextTouchServiceGetData = z.object({ +export const zIntStorageSlotReactivation1mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -107590,9 +111465,9 @@ export const zIntStorageSlotNextTouchServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotNextTouchServiceGetResponse = zGetIntStorageSlotNextTouchResponse; +export const zIntStorageSlotReactivation1mServiceGetResponse = zGetIntStorageSlotReactivation1mResponse; -export const zIntStorageSlotReactivation1mServiceListData = z.object({ +export const zIntStorageSlotReactivation6mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -107896,9 +111771,9 @@ export const zIntStorageSlotReactivation1mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation1mServiceListResponse = zListIntStorageSlotReactivation1mResponse; +export const zIntStorageSlotReactivation6mServiceListResponse = zListIntStorageSlotReactivation6mResponse; -export const zIntStorageSlotReactivation1mServiceGetData = z.object({ +export const zIntStorageSlotReactivation6mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -107914,9 +111789,9 @@ export const zIntStorageSlotReactivation1mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation1mServiceGetResponse = zGetIntStorageSlotReactivation1mResponse; +export const zIntStorageSlotReactivation6mServiceGetResponse = zGetIntStorageSlotReactivation6mResponse; -export const zIntStorageSlotReactivation6mServiceListData = z.object({ +export const zIntStorageSlotReactivation12mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -108220,9 +112095,9 @@ export const zIntStorageSlotReactivation6mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation6mServiceListResponse = zListIntStorageSlotReactivation6mResponse; +export const zIntStorageSlotReactivation12mServiceListResponse = zListIntStorageSlotReactivation12mResponse; -export const zIntStorageSlotReactivation6mServiceGetData = z.object({ +export const zIntStorageSlotReactivation12mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -108238,9 +112113,9 @@ export const zIntStorageSlotReactivation6mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation6mServiceGetResponse = zGetIntStorageSlotReactivation6mResponse; +export const zIntStorageSlotReactivation12mServiceGetResponse = zGetIntStorageSlotReactivation12mResponse; -export const zIntStorageSlotReactivation12mServiceListData = z.object({ +export const zIntStorageSlotReactivation18mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -108544,9 +112419,9 @@ export const zIntStorageSlotReactivation12mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation12mServiceListResponse = zListIntStorageSlotReactivation12mResponse; +export const zIntStorageSlotReactivation18mServiceListResponse = zListIntStorageSlotReactivation18mResponse; -export const zIntStorageSlotReactivation12mServiceGetData = z.object({ +export const zIntStorageSlotReactivation18mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -108562,9 +112437,9 @@ export const zIntStorageSlotReactivation12mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation12mServiceGetResponse = zGetIntStorageSlotReactivation12mResponse; +export const zIntStorageSlotReactivation18mServiceGetResponse = zGetIntStorageSlotReactivation18mResponse; -export const zIntStorageSlotReactivation18mServiceListData = z.object({ +export const zIntStorageSlotReactivation24mServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -108868,9 +112743,9 @@ export const zIntStorageSlotReactivation18mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation18mServiceListResponse = zListIntStorageSlotReactivation18mResponse; +export const zIntStorageSlotReactivation24mServiceListResponse = zListIntStorageSlotReactivation24mResponse; -export const zIntStorageSlotReactivation18mServiceGetData = z.object({ +export const zIntStorageSlotReactivation24mServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -108886,9 +112761,9 @@ export const zIntStorageSlotReactivation18mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation18mServiceGetResponse = zGetIntStorageSlotReactivation18mResponse; +export const zIntStorageSlotReactivation24mServiceGetResponse = zGetIntStorageSlotReactivation24mResponse; -export const zIntStorageSlotReactivation24mServiceListData = z.object({ +export const zIntStorageSlotReadServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -108977,72 +112852,6 @@ export const zIntStorageSlotReactivation24mServiceListData = 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() @@ -109109,72 +112918,6 @@ export const zIntStorageSlotReactivation24mServiceListData = 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() @@ -109192,9 +112935,9 @@ export const zIntStorageSlotReactivation24mServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation24mServiceListResponse = zListIntStorageSlotReactivation24mResponse; +export const zIntStorageSlotReadServiceListResponse = zListIntStorageSlotReadResponse; -export const zIntStorageSlotReactivation24mServiceGetData = z.object({ +export const zIntStorageSlotReadServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -109210,9 +112953,9 @@ export const zIntStorageSlotReactivation24mServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReactivation24mServiceGetResponse = zGetIntStorageSlotReactivation24mResponse; +export const zIntStorageSlotReadServiceGetResponse = zGetIntStorageSlotReadResponse; -export const zIntStorageSlotReadServiceListData = z.object({ +export const zIntStorageSlotStateServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -109292,15 +113035,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() @@ -109367,6 +113101,366 @@ 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+)*$/))), + 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+)*$/))), + 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+)*$/))), page_size: z.optional( z .int() @@ -109384,9 +113478,9 @@ export const zIntStorageSlotReadServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotReadServiceListResponse = zListIntStorageSlotReadResponse; +export const zIntStorageSlotStateServiceListResponse = zListIntStorageSlotStateResponse; -export const zIntStorageSlotReadServiceGetData = z.object({ +export const zIntStorageSlotStateServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z @@ -109402,13 +113496,22 @@ export const zIntStorageSlotReadServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotReadServiceGetResponse = zGetIntStorageSlotReadResponse; +export const zIntStorageSlotStateServiceGetResponse = zGetIntStorageSlotStateResponse; -export const zIntStorageSlotStateServiceListData = 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() @@ -109475,15 +113578,6 @@ export const zIntStorageSlotStateServiceListData = 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() @@ -109927,17 +114021,12 @@ export const zIntStorageSlotStateServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateServiceListResponse = zListIntStorageSlotStateResponse; +export const zIntStorageSlotStateByAddressServiceListResponse = zListIntStorageSlotStateByAddressResponse; -export const zIntStorageSlotStateServiceGetData = 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()), }); @@ -109945,22 +114034,13 @@ export const zIntStorageSlotStateServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateServiceGetResponse = zGetIntStorageSlotStateResponse; +export const zIntStorageSlotStateByAddressServiceGetResponse = zGetIntStorageSlotStateByAddressResponse; -export const zIntStorageSlotStateByAddressServiceListData = z.object({ +export const zIntStorageSlotStateByBlockServiceListData = 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() @@ -110470,12 +114550,17 @@ export const zIntStorageSlotStateByAddressServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateByAddressServiceListResponse = zListIntStorageSlotStateByAddressResponse; +export const zIntStorageSlotStateByBlockServiceListResponse = zListIntStorageSlotStateByBlockResponse; -export const zIntStorageSlotStateByAddressServiceGetData = z.object({ +export const zIntStorageSlotStateByBlockServiceGetData = 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()), }); @@ -110483,13 +114568,22 @@ export const zIntStorageSlotStateByAddressServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateByAddressServiceGetResponse = zGetIntStorageSlotStateByAddressResponse; +export const zIntStorageSlotStateByBlockServiceGetResponse = zGetIntStorageSlotStateByBlockResponse; -export const zIntStorageSlotStateByBlockServiceListData = 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() @@ -110556,6 +114650,15 @@ export const zIntStorageSlotStateByBlockServiceListData = 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() @@ -110622,7 +114725,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( @@ -110630,7 +114733,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( @@ -110638,7 +114741,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( @@ -110646,7 +114749,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( @@ -110654,7 +114757,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( @@ -110662,7 +114765,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( @@ -110670,7 +114773,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( @@ -110678,7 +114781,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( @@ -110686,9 +114789,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( @@ -110700,7 +114803,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_ne: z.optional( + net_bytes_delta_ne: z.optional( z.coerce .bigint() .check( @@ -110712,7 +114815,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_lt: z.optional( + net_bytes_delta_lt: z.optional( z.coerce .bigint() .check( @@ -110724,7 +114827,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_lte: z.optional( + net_bytes_delta_lte: z.optional( z.coerce .bigint() .check( @@ -110736,7 +114839,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_gt: z.optional( + net_bytes_delta_gt: z.optional( z.coerce .bigint() .check( @@ -110748,7 +114851,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_gte: z.optional( + net_bytes_delta_gte: z.optional( z.coerce .bigint() .check( @@ -110760,7 +114863,7 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ }) ) ), - bytes_delta_between_min: z.optional( + net_bytes_delta_between_min: z.optional( z.coerce .bigint() .check( @@ -110772,7 +114875,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( @@ -110784,8 +114887,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() @@ -110999,17 +115298,12 @@ export const zIntStorageSlotStateByBlockServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateByBlockServiceListResponse = zListIntStorageSlotStateByBlockResponse; +export const zIntStorageSlotStateWithExpiryServiceListResponse = zListIntStorageSlotStateWithExpiryResponse; -export const zIntStorageSlotStateByBlockServiceGetData = 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()), }); @@ -111017,13 +115311,22 @@ export const zIntStorageSlotStateByBlockServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateByBlockServiceGetResponse = zGetIntStorageSlotStateByBlockResponse; +export const zIntStorageSlotStateWithExpiryServiceGetResponse = zGetIntStorageSlotStateWithExpiryResponse; -export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ +export const zIntStorageSlotStateWithExpiryByAddressServiceListData = 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()), @@ -111099,15 +115402,6 @@ export const zIntStorageSlotStateWithExpiryServiceListData = 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() @@ -111747,12 +116041,13 @@ export const zIntStorageSlotStateWithExpiryServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryServiceListResponse = zListIntStorageSlotStateWithExpiryResponse; +export const zIntStorageSlotStateWithExpiryByAddressServiceListResponse = + zListIntStorageSlotStateWithExpiryByAddressResponse; -export const zIntStorageSlotStateWithExpiryServiceGetData = z.object({ +export const zIntStorageSlotStateWithExpiryByAddressServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - expiry_policy: z.string(), + address: z.string(), }), query: z.optional(z.never()), }); @@ -111760,22 +116055,14 @@ export const zIntStorageSlotStateWithExpiryServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryServiceGetResponse = zGetIntStorageSlotStateWithExpiryResponse; +export const zIntStorageSlotStateWithExpiryByAddressServiceGetResponse = + zGetIntStorageSlotStateWithExpiryByAddressResponse; -export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ +export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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()), @@ -112490,13 +116777,13 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByAddressServiceListResponse = - zListIntStorageSlotStateWithExpiryByAddressResponse; +export const zIntStorageSlotStateWithExpiryByBlockServiceListResponse = + zListIntStorageSlotStateWithExpiryByBlockResponse; -export const zIntStorageSlotStateWithExpiryByAddressServiceGetData = z.object({ +export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ - address: z.string(), + expiry_policy: z.string(), }), query: z.optional(z.never()), }); @@ -112504,24 +116791,105 @@ export const zIntStorageSlotStateWithExpiryByAddressServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByAddressServiceGetResponse = - zGetIntStorageSlotStateWithExpiryByAddressResponse; +export const zIntStorageSlotStateWithExpiryByBlockServiceGetResponse = zGetIntStorageSlotStateWithExpiryByBlockResponse; -export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( @@ -112529,7 +116897,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( @@ -112537,7 +116905,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( @@ -112545,7 +116913,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( @@ -112553,7 +116921,205 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( + 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( + 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+)*$/))), + parent_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' }) + ) + ), + parent_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' }) + ) + ), + parent_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' }) + ) + ), + parent_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' }) + ) + ), + parent_call_frame_id_gt: z.optional( z .int() .check( @@ -112561,7 +117127,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_gte: z.optional( + parent_call_frame_id_gte: z.optional( z .int() .check( @@ -112569,7 +117135,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_min: z.optional( + parent_call_frame_id_between_min: z.optional( z .int() .check( @@ -112577,7 +117143,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - block_number_between_max_value: z.optional( + parent_call_frame_id_between_max_value: z.optional( z .int() .check( @@ -112585,9 +117151,9 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( + 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( @@ -112595,7 +117161,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_ne: z.optional( + depth_ne: z.optional( z .int() .check( @@ -112603,7 +117169,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lt: z.optional( + depth_lt: z.optional( z .int() .check( @@ -112611,7 +117177,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_lte: z.optional( + depth_lte: z.optional( z .int() .check( @@ -112619,7 +117185,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gt: z.optional( + depth_gt: z.optional( z .int() .check( @@ -112627,7 +117193,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_gte: z.optional( + depth_gte: z.optional( z .int() .check( @@ -112635,7 +117201,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_min: z.optional( + depth_between_min: z.optional( z .int() .check( @@ -112643,7 +117209,7 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) ) ), - updated_date_time_between_max_value: z.optional( + depth_between_max_value: z.optional( z .int() .check( @@ -112651,564 +117217,609 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = 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( - 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_ne: z.optional( - z - .int() + opcode_count_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() + opcode_count_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() + opcode_count_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() + opcode_count_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() + opcode_count_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() + opcode_count_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() + opcode_count_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( + 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_ne: 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', }) ) ), - net_bytes_delta_lt: 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', }) ) ), - net_bytes_delta_lte: 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', }) ) ), - net_bytes_delta_gt: 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', }) ) ), - net_bytes_delta_gte: 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', }) ) ), - net_bytes_delta_between_min: 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', }) ) ), - net_bytes_delta_between_max_value: 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', }) ) ), - 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_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_ne: 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_slots_lt: 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_slots_lte: 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_slots_gt: 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_slots_gte: 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_slots_between_min: 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', }) ) ), - cumulative_net_slots_between_max_value: 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', }) ) ), - 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_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', }) ) ), - cumulative_net_bytes_ne: 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', }) ) ), - cumulative_net_bytes_lt: 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', }) ) ), - cumulative_net_bytes_lte: 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', }) ) ), - cumulative_net_bytes_gt: 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', }) ) ), - cumulative_net_bytes_gte: 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', }) ) ), - cumulative_net_bytes_between_min: 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', }) ) ), - cumulative_net_bytes_between_max_value: 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', }) ) ), - 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_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('-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_refund_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', + }) + ) + ), + 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+)*$/))), + intrinsic_gas_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', + }) + ) + ), + intrinsic_gas_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( + 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() @@ -113226,13 +117837,19 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceListData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByBlockServiceListResponse = - zListIntStorageSlotStateWithExpiryByBlockResponse; +export const zIntTransactionCallFrameServiceListResponse = zListIntTransactionCallFrameResponse; -export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = 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()), }); @@ -113240,9 +117857,9 @@ export const zIntStorageSlotStateWithExpiryByBlockServiceGetData = z.object({ /** * OK */ -export const zIntStorageSlotStateWithExpiryByBlockServiceGetResponse = zGetIntStorageSlotStateWithExpiryByBlockResponse; +export const zIntTransactionCallFrameServiceGetResponse = zGetIntTransactionCallFrameResponse; -export const zIntTransactionCallFrameServiceListData = z.object({ +export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -113404,6 +118021,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() @@ -113536,166 +118171,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_cumulative_eq: z.optional( z.coerce .bigint() .check( @@ -113705,7 +118345,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_ne: z.optional( + gas_cumulative_ne: z.optional( z.coerce .bigint() .check( @@ -113715,7 +118355,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_lt: z.optional( + gas_cumulative_lt: z.optional( z.coerce .bigint() .check( @@ -113725,7 +118365,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_lte: z.optional( + gas_cumulative_lte: z.optional( z.coerce .bigint() .check( @@ -113735,7 +118375,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_gt: z.optional( + gas_cumulative_gt: z.optional( z.coerce .bigint() .check( @@ -113745,7 +118385,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_gte: z.optional( + gas_cumulative_gte: z.optional( z.coerce .bigint() .check( @@ -113755,7 +118395,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_between_min: z.optional( + gas_cumulative_between_min: z.optional( z.coerce .bigint() .check( @@ -113765,7 +118405,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - opcode_count_between_max_value: z.optional( + gas_cumulative_between_max_value: z.optional( z.coerce .bigint() .check( @@ -113775,8 +118415,8 @@ 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+)*$/))), + 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() @@ -113857,9 +118497,91 @@ 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( + 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(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_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + memory_words_sum_before_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', + }) + ) + ), + 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( @@ -113869,7 +118591,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_ne: z.optional( + memory_words_sum_after_ne: z.optional( z.coerce .bigint() .check( @@ -113879,7 +118601,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_lt: z.optional( + memory_words_sum_after_lt: z.optional( z.coerce .bigint() .check( @@ -113889,7 +118611,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_lte: z.optional( + memory_words_sum_after_lte: z.optional( z.coerce .bigint() .check( @@ -113899,7 +118621,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_gt: z.optional( + memory_words_sum_after_gt: z.optional( z.coerce .bigint() .check( @@ -113909,7 +118631,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_gte: z.optional( + memory_words_sum_after_gte: z.optional( z.coerce .bigint() .check( @@ -113919,7 +118641,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_between_min: z.optional( + memory_words_sum_after_between_min: z.optional( z.coerce .bigint() .check( @@ -113929,7 +118651,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_between_max_value: z.optional( + memory_words_sum_after_between_max_value: z.optional( z.coerce .bigint() .check( @@ -113939,9 +118661,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( + 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( @@ -113951,7 +118673,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_ne: z.optional( + memory_words_sq_sum_before_ne: z.optional( z.coerce .bigint() .check( @@ -113961,7 +118683,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_lt: z.optional( + memory_words_sq_sum_before_lt: z.optional( z.coerce .bigint() .check( @@ -113971,7 +118693,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_lte: z.optional( + memory_words_sq_sum_before_lte: z.optional( z.coerce .bigint() .check( @@ -113981,7 +118703,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_gt: z.optional( + memory_words_sq_sum_before_gt: z.optional( z.coerce .bigint() .check( @@ -113991,7 +118713,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_gte: z.optional( + memory_words_sq_sum_before_gte: z.optional( z.coerce .bigint() .check( @@ -114001,7 +118723,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_between_min: z.optional( + memory_words_sq_sum_before_between_min: z.optional( z.coerce .bigint() .check( @@ -114011,7 +118733,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_cumulative_between_max_value: z.optional( + memory_words_sq_sum_before_between_max_value: z.optional( z.coerce .bigint() .check( @@ -114021,9 +118743,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( + 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( @@ -114033,7 +118755,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_ne: z.optional( + memory_words_sq_sum_after_ne: z.optional( z.coerce .bigint() .check( @@ -114043,7 +118765,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_lt: z.optional( + memory_words_sq_sum_after_lt: z.optional( z.coerce .bigint() .check( @@ -114053,7 +118775,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_lte: z.optional( + memory_words_sq_sum_after_lte: z.optional( z.coerce .bigint() .check( @@ -114063,7 +118785,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_gt: z.optional( + memory_words_sq_sum_after_gt: z.optional( z.coerce .bigint() .check( @@ -114073,7 +118795,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_gte: z.optional( + memory_words_sq_sum_after_gte: z.optional( z.coerce .bigint() .check( @@ -114083,7 +118805,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_between_min: z.optional( + memory_words_sq_sum_after_between_min: z.optional( z.coerce .bigint() .check( @@ -114093,7 +118815,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - gas_refund_between_max_value: z.optional( + memory_words_sq_sum_after_between_max_value: z.optional( z.coerce .bigint() .check( @@ -114103,9 +118825,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( + 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( @@ -114115,7 +118837,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_ne: z.optional( + memory_expansion_gas_ne: z.optional( z.coerce .bigint() .check( @@ -114125,7 +118847,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_lt: z.optional( + memory_expansion_gas_lt: z.optional( z.coerce .bigint() .check( @@ -114135,7 +118857,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_lte: z.optional( + memory_expansion_gas_lte: z.optional( z.coerce .bigint() .check( @@ -114145,7 +118867,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_gt: z.optional( + memory_expansion_gas_gt: z.optional( z.coerce .bigint() .check( @@ -114155,7 +118877,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_gte: z.optional( + memory_expansion_gas_gte: z.optional( z.coerce .bigint() .check( @@ -114165,7 +118887,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_between_min: z.optional( + memory_expansion_gas_between_min: z.optional( z.coerce .bigint() .check( @@ -114175,7 +118897,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - intrinsic_gas_between_max_value: z.optional( + memory_expansion_gas_between_max_value: z.optional( z.coerce .bigint() .check( @@ -114185,9 +118907,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( + 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( @@ -114197,7 +118919,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_ne: z.optional( + cold_access_count_ne: z.optional( z.coerce .bigint() .check( @@ -114207,7 +118929,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_lt: z.optional( + cold_access_count_lt: z.optional( z.coerce .bigint() .check( @@ -114217,7 +118939,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_lte: z.optional( + cold_access_count_lte: z.optional( z.coerce .bigint() .check( @@ -114227,7 +118949,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_gt: z.optional( + cold_access_count_gt: z.optional( z.coerce .bigint() .check( @@ -114237,7 +118959,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_gte: z.optional( + cold_access_count_gte: z.optional( z.coerce .bigint() .check( @@ -114247,7 +118969,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_between_min: z.optional( + cold_access_count_between_min: z.optional( z.coerce .bigint() .check( @@ -114257,7 +118979,7 @@ export const zIntTransactionCallFrameServiceListData = z.object({ }) ) ), - receipt_gas_used_between_max_value: z.optional( + cold_access_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -114267,8 +118989,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+)*$/))), + 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() @@ -114286,9 +119008,9 @@ export const zIntTransactionCallFrameServiceListData = z.object({ /** * OK */ -export const zIntTransactionCallFrameServiceListResponse = zListIntTransactionCallFrameResponse; +export const zIntTransactionCallFrameOpcodeGasServiceListResponse = zListIntTransactionCallFrameOpcodeGasResponse; -export const zIntTransactionCallFrameServiceGetData = z.object({ +export const zIntTransactionCallFrameOpcodeGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -114306,9 +119028,9 @@ export const zIntTransactionCallFrameServiceGetData = z.object({ /** * OK */ -export const zIntTransactionCallFrameServiceGetResponse = zGetIntTransactionCallFrameResponse; +export const zIntTransactionCallFrameOpcodeGasServiceGetResponse = zGetIntTransactionCallFrameOpcodeGasResponse; -export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ +export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -114612,413 +119334,15 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ ), 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+)*$/))), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - count_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', - }) - ) - ), - 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('0'), { error: 'Invalid value: Expected uint64 to be >= 0' }), - z.maximum(BigInt('18446744073709551615'), { - error: 'Invalid value: Expected uint64 to be <= 18446744073709551615', - }) - ) - ), - gas_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_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_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_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_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_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_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+)*$/))), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - error_count_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', - }) - ) - ), - 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(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_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', - }) - ) - ), - memory_words_sum_before_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', - }) - ) - ), - memory_words_sum_before_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', - }) - ) - ), - memory_words_sum_before_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', - }) - ) - ), - memory_words_sum_before_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', - }) - ) - ), - memory_words_sum_before_between_min: z.optional( - z.coerce - .bigint() + .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' }) ) ), - memory_words_sum_before_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+)*$/))), + count_eq: z.optional( z.coerce .bigint() .check( @@ -115028,9 +119352,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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( + count_ne: z.optional( z.coerce .bigint() .check( @@ -115040,7 +119362,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_ne: z.optional( + count_lt: z.optional( z.coerce .bigint() .check( @@ -115050,7 +119372,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_lt: z.optional( + count_lte: z.optional( z.coerce .bigint() .check( @@ -115060,7 +119382,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_lte: z.optional( + count_gt: z.optional( z.coerce .bigint() .check( @@ -115070,7 +119392,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_gt: z.optional( + count_gte: z.optional( z.coerce .bigint() .check( @@ -115080,7 +119402,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_gte: z.optional( + count_between_min: z.optional( z.coerce .bigint() .check( @@ -115090,7 +119412,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_between_min: z.optional( + count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115100,7 +119422,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sum_after_between_max_value: 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( @@ -115110,9 +119434,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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( + gas_ne: z.optional( z.coerce .bigint() .check( @@ -115122,7 +119444,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_ne: z.optional( + gas_lt: z.optional( z.coerce .bigint() .check( @@ -115132,7 +119454,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_lt: z.optional( + gas_lte: z.optional( z.coerce .bigint() .check( @@ -115142,7 +119464,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_lte: z.optional( + gas_gt: z.optional( z.coerce .bigint() .check( @@ -115152,7 +119474,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_gt: z.optional( + gas_gte: z.optional( z.coerce .bigint() .check( @@ -115162,7 +119484,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_gte: z.optional( + gas_between_min: z.optional( z.coerce .bigint() .check( @@ -115172,7 +119494,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_between_min: z.optional( + gas_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115182,7 +119504,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_before_between_max_value: 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( @@ -115192,9 +119516,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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( + gas_compute_ne: z.optional( z.coerce .bigint() .check( @@ -115204,7 +119526,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_ne: z.optional( + gas_compute_lt: z.optional( z.coerce .bigint() .check( @@ -115214,7 +119536,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_lt: z.optional( + gas_compute_lte: z.optional( z.coerce .bigint() .check( @@ -115224,7 +119546,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_lte: z.optional( + gas_compute_gt: z.optional( z.coerce .bigint() .check( @@ -115234,7 +119556,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_gt: z.optional( + gas_compute_gte: z.optional( z.coerce .bigint() .check( @@ -115244,7 +119566,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_gte: z.optional( + gas_compute_between_min: z.optional( z.coerce .bigint() .check( @@ -115254,7 +119576,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_between_min: z.optional( + gas_compute_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115264,7 +119586,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_words_sq_sum_after_between_max_value: 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( @@ -115274,9 +119598,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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( + gas_memory_ne: z.optional( z.coerce .bigint() .check( @@ -115286,7 +119608,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_ne: z.optional( + gas_memory_lt: z.optional( z.coerce .bigint() .check( @@ -115296,7 +119618,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_lt: z.optional( + gas_memory_lte: z.optional( z.coerce .bigint() .check( @@ -115306,7 +119628,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_lte: z.optional( + gas_memory_gt: z.optional( z.coerce .bigint() .check( @@ -115316,7 +119638,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_gt: z.optional( + gas_memory_gte: z.optional( z.coerce .bigint() .check( @@ -115326,7 +119648,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_gte: z.optional( + gas_memory_between_min: z.optional( z.coerce .bigint() .check( @@ -115336,7 +119658,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_between_min: z.optional( + gas_memory_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115346,7 +119668,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - memory_expansion_gas_between_max_value: 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( @@ -115356,9 +119680,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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( + gas_address_access_ne: z.optional( z.coerce .bigint() .check( @@ -115368,7 +119690,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_ne: z.optional( + gas_address_access_lt: z.optional( z.coerce .bigint() .check( @@ -115378,7 +119700,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_lt: z.optional( + gas_address_access_lte: z.optional( z.coerce .bigint() .check( @@ -115388,7 +119710,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_lte: z.optional( + gas_address_access_gt: z.optional( z.coerce .bigint() .check( @@ -115398,7 +119720,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_gt: z.optional( + gas_address_access_gte: z.optional( z.coerce .bigint() .check( @@ -115408,7 +119730,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_gte: z.optional( + gas_address_access_between_min: z.optional( z.coerce .bigint() .check( @@ -115418,7 +119740,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_between_min: z.optional( + gas_address_access_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115428,7 +119750,9 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - cold_access_count_between_max_value: 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( @@ -115438,53 +119762,7 @@ export const zIntTransactionCallFrameOpcodeGasServiceListData = z.object({ }) ) ), - 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() - .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 zIntTransactionCallFrameOpcodeGasServiceListResponse = zListIntTransactionCallFrameOpcodeGasResponse; - -export const zIntTransactionCallFrameOpcodeGasServiceGetData = 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 zIntTransactionCallFrameOpcodeGasServiceGetResponse = zGetIntTransactionCallFrameOpcodeGasResponse; - -export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object({ - body: z.optional(z.never()), - path: z.optional(z.never()), - query: z.optional( - z.object({ - block_number_eq: z.optional( + gas_state_growth_ne: z.optional( z.coerce .bigint() .check( @@ -115494,7 +119772,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_ne: z.optional( + gas_state_growth_lt: z.optional( z.coerce .bigint() .check( @@ -115504,7 +119782,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_lt: z.optional( + gas_state_growth_lte: z.optional( z.coerce .bigint() .check( @@ -115514,7 +119792,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_lte: z.optional( + gas_state_growth_gt: z.optional( z.coerce .bigint() .check( @@ -115524,7 +119802,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_gt: z.optional( + gas_state_growth_gte: z.optional( z.coerce .bigint() .check( @@ -115534,7 +119812,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_gte: z.optional( + gas_state_growth_between_min: z.optional( z.coerce .bigint() .check( @@ -115544,7 +119822,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_between_min: z.optional( + gas_state_growth_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115554,7 +119832,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - block_number_between_max_value: 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( @@ -115564,234 +119844,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = 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(/^[^,]+(,[^,]+)*$/))), - 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()), - 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() - .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+)*$/))), - count_eq: z.optional( + gas_history_ne: z.optional( z.coerce .bigint() .check( @@ -115801,7 +119854,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_ne: z.optional( + gas_history_lt: z.optional( z.coerce .bigint() .check( @@ -115811,7 +119864,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_lt: z.optional( + gas_history_lte: z.optional( z.coerce .bigint() .check( @@ -115821,7 +119874,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_lte: z.optional( + gas_history_gt: z.optional( z.coerce .bigint() .check( @@ -115831,7 +119884,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_gt: z.optional( + gas_history_gte: z.optional( z.coerce .bigint() .check( @@ -115841,7 +119894,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_gte: z.optional( + gas_history_between_min: z.optional( z.coerce .bigint() .check( @@ -115851,7 +119904,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_between_min: z.optional( + gas_history_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115861,7 +119914,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - count_between_max_value: 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( @@ -115871,9 +119926,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = 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_bloom_topics_ne: z.optional( z.coerce .bigint() .check( @@ -115883,7 +119936,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_ne: z.optional( + gas_bloom_topics_lt: z.optional( z.coerce .bigint() .check( @@ -115893,7 +119946,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_lt: z.optional( + gas_bloom_topics_lte: z.optional( z.coerce .bigint() .check( @@ -115903,7 +119956,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_lte: z.optional( + gas_bloom_topics_gt: z.optional( z.coerce .bigint() .check( @@ -115913,7 +119966,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_gt: z.optional( + gas_bloom_topics_gte: z.optional( z.coerce .bigint() .check( @@ -115923,7 +119976,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_gte: z.optional( + gas_bloom_topics_between_min: z.optional( z.coerce .bigint() .check( @@ -115933,7 +119986,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_between_min: z.optional( + gas_bloom_topics_between_max_value: z.optional( z.coerce .bigint() .check( @@ -115943,7 +119996,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_between_max_value: 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( @@ -115953,9 +120008,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = 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_compute_eq: z.optional( + gas_block_size_ne: z.optional( z.coerce .bigint() .check( @@ -115965,7 +120018,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_ne: z.optional( + gas_block_size_lt: z.optional( z.coerce .bigint() .check( @@ -115975,7 +120028,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_lt: z.optional( + gas_block_size_lte: z.optional( z.coerce .bigint() .check( @@ -115985,7 +120038,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_lte: z.optional( + gas_block_size_gt: z.optional( z.coerce .bigint() .check( @@ -115995,7 +120048,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_gt: z.optional( + gas_block_size_gte: z.optional( z.coerce .bigint() .check( @@ -116005,7 +120058,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_gte: z.optional( + gas_block_size_between_min: z.optional( z.coerce .bigint() .check( @@ -116015,7 +120068,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_between_min: z.optional( + gas_block_size_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116025,19 +120078,55 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_compute_between_max_value: z.optional( - z.coerce - .bigint() + 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() .check( - 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(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) ) ), - 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( + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zIntTransactionCallFrameOpcodeResourceGasServiceListResponse = + zListIntTransactionCallFrameOpcodeResourceGasResponse; + +export const zIntTransactionCallFrameOpcodeResourceGasServiceGetData = 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 zIntTransactionCallFrameOpcodeResourceGasServiceGetResponse = + zGetIntTransactionCallFrameOpcodeResourceGasResponse; + +export const zIntTransactionOpcodeGasServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + block_number_eq: z.optional( z.coerce .bigint() .check( @@ -116047,7 +120136,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_ne: z.optional( + block_number_ne: z.optional( z.coerce .bigint() .check( @@ -116057,7 +120146,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_lt: z.optional( + block_number_lt: z.optional( z.coerce .bigint() .check( @@ -116067,7 +120156,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_lte: z.optional( + block_number_lte: z.optional( z.coerce .bigint() .check( @@ -116077,7 +120166,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_gt: z.optional( + block_number_gt: z.optional( z.coerce .bigint() .check( @@ -116087,7 +120176,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_gte: z.optional( + block_number_gte: z.optional( z.coerce .bigint() .check( @@ -116097,7 +120186,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_between_min: z.optional( + block_number_between_min: z.optional( z.coerce .bigint() .check( @@ -116107,7 +120196,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_memory_between_max_value: z.optional( + block_number_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116117,91 +120206,168 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - 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() + 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(/^[^,]+(,[^,]+)*$/))), + 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() .check( - 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_address_access_ne: z.optional( - z.coerce - .bigint() + updated_date_time_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' }) ) ), - gas_address_access_lt: z.optional( - z.coerce - .bigint() + updated_date_time_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' }) ) ), - gas_address_access_lte: z.optional( - z.coerce - .bigint() + updated_date_time_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' }) ) ), - gas_address_access_gt: z.optional( - z.coerce - .bigint() + updated_date_time_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_address_access_gte: z.optional( - z.coerce - .bigint() + updated_date_time_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_address_access_between_min: z.optional( - z.coerce - .bigint() + updated_date_time_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_address_access_between_max_value: z.optional( - z.coerce - .bigint() + updated_date_time_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' }) ) ), - 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( + 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+)*$/))), + count_eq: z.optional( z.coerce .bigint() .check( @@ -116211,7 +120377,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_ne: z.optional( + count_ne: z.optional( z.coerce .bigint() .check( @@ -116221,7 +120387,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_lt: z.optional( + count_lt: z.optional( z.coerce .bigint() .check( @@ -116231,7 +120397,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_lte: z.optional( + count_lte: z.optional( z.coerce .bigint() .check( @@ -116241,7 +120407,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_gt: z.optional( + count_gt: z.optional( z.coerce .bigint() .check( @@ -116251,7 +120417,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_gte: z.optional( + count_gte: z.optional( z.coerce .bigint() .check( @@ -116261,7 +120427,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_between_min: z.optional( + count_between_min: z.optional( z.coerce .bigint() .check( @@ -116271,7 +120437,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_state_growth_between_max_value: z.optional( + count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116281,9 +120447,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - 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( + 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( @@ -116293,7 +120459,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_ne: z.optional( + gas_ne: z.optional( z.coerce .bigint() .check( @@ -116303,7 +120469,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_lt: z.optional( + gas_lt: z.optional( z.coerce .bigint() .check( @@ -116313,7 +120479,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_lte: z.optional( + gas_lte: z.optional( z.coerce .bigint() .check( @@ -116323,7 +120489,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_gt: z.optional( + gas_gt: z.optional( z.coerce .bigint() .check( @@ -116333,7 +120499,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_gte: z.optional( + gas_gte: z.optional( z.coerce .bigint() .check( @@ -116343,7 +120509,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_between_min: z.optional( + gas_between_min: z.optional( z.coerce .bigint() .check( @@ -116353,7 +120519,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_history_between_max_value: z.optional( + gas_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116363,9 +120529,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - 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( + 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( @@ -116375,7 +120541,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_ne: z.optional( + gas_cumulative_ne: z.optional( z.coerce .bigint() .check( @@ -116385,7 +120551,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_lt: z.optional( + gas_cumulative_lt: z.optional( z.coerce .bigint() .check( @@ -116395,7 +120561,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_lte: z.optional( + gas_cumulative_lte: z.optional( z.coerce .bigint() .check( @@ -116405,7 +120571,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_gt: z.optional( + gas_cumulative_gt: z.optional( z.coerce .bigint() .check( @@ -116415,7 +120581,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_gte: z.optional( + gas_cumulative_gte: z.optional( z.coerce .bigint() .check( @@ -116425,7 +120591,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_between_min: z.optional( + gas_cumulative_between_min: z.optional( z.coerce .bigint() .check( @@ -116435,7 +120601,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_bloom_topics_between_max_value: z.optional( + gas_cumulative_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116445,9 +120611,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - 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( + 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( @@ -116457,7 +120623,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_ne: z.optional( + error_count_ne: z.optional( z.coerce .bigint() .check( @@ -116467,7 +120633,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_lt: z.optional( + error_count_lt: z.optional( z.coerce .bigint() .check( @@ -116477,7 +120643,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_lte: z.optional( + error_count_lte: z.optional( z.coerce .bigint() .check( @@ -116487,7 +120653,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_gt: z.optional( + error_count_gt: z.optional( z.coerce .bigint() .check( @@ -116497,7 +120663,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_gte: z.optional( + error_count_gte: z.optional( z.coerce .bigint() .check( @@ -116507,7 +120673,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_between_min: z.optional( + error_count_between_min: z.optional( z.coerce .bigint() .check( @@ -116517,7 +120683,7 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - gas_block_size_between_max_value: z.optional( + error_count_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116527,8 +120693,8 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object }) ) ), - 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+)*$/))), + 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+)*$/))), page_size: z.optional( z .int() @@ -116546,10 +120712,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceListData = z.object /** * OK */ -export const zIntTransactionCallFrameOpcodeResourceGasServiceListResponse = - zListIntTransactionCallFrameOpcodeResourceGasResponse; +export const zIntTransactionOpcodeGasServiceListResponse = zListIntTransactionOpcodeGasResponse; -export const zIntTransactionCallFrameOpcodeResourceGasServiceGetData = z.object({ +export const zIntTransactionOpcodeGasServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -116567,10 +120732,9 @@ export const zIntTransactionCallFrameOpcodeResourceGasServiceGetData = z.object( /** * OK */ -export const zIntTransactionCallFrameOpcodeResourceGasServiceGetResponse = - zGetIntTransactionCallFrameOpcodeResourceGasResponse; +export const zIntTransactionOpcodeGasServiceGetResponse = zGetIntTransactionOpcodeGasResponse; -export const zIntTransactionOpcodeGasServiceListData = z.object({ +export const zIntTransactionReceiptSizeServiceListData = z.object({ body: z.optional(z.never()), path: z.optional(z.never()), query: z.optional( @@ -116666,15 +120830,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()), @@ -116816,7 +120971,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( + receipt_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -116826,7 +120981,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_ne: z.optional( + receipt_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -116836,7 +120991,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_lt: z.optional( + receipt_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -116846,7 +121001,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_lte: z.optional( + receipt_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -116856,7 +121011,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_gt: z.optional( + receipt_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -116866,7 +121021,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_gte: z.optional( + receipt_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -116876,7 +121031,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_between_min: z.optional( + receipt_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -116886,7 +121041,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - count_between_max_value: z.optional( + receipt_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -116896,91 +121051,75 @@ 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( - z.coerce - .bigint() + receipt_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + receipt_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_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' }) ) ), - gas_ne: z.optional( - z.coerce - .bigint() + log_count_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' }) ) ), - gas_lt: z.optional( - z.coerce - .bigint() + log_count_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' }) ) ), - gas_lte: z.optional( - z.coerce - .bigint() + log_count_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' }) ) ), - gas_gt: z.optional( - z.coerce - .bigint() + log_count_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_gte: z.optional( - z.coerce - .bigint() + log_count_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_between_min: z.optional( - z.coerce - .bigint() + log_count_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_between_max_value: z.optional( - z.coerce - .bigint() + log_count_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' }) ) ), - 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( + log_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_data_bytes_eq: z.optional( z.coerce .bigint() .check( @@ -116990,7 +121129,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_ne: z.optional( + log_data_bytes_ne: z.optional( z.coerce .bigint() .check( @@ -117000,7 +121139,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_lt: z.optional( + log_data_bytes_lt: z.optional( z.coerce .bigint() .check( @@ -117010,7 +121149,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_lte: z.optional( + log_data_bytes_lte: z.optional( z.coerce .bigint() .check( @@ -117020,7 +121159,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_gt: z.optional( + log_data_bytes_gt: z.optional( z.coerce .bigint() .check( @@ -117030,7 +121169,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_gte: z.optional( + log_data_bytes_gte: z.optional( z.coerce .bigint() .check( @@ -117040,7 +121179,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_between_min: z.optional( + log_data_bytes_between_min: z.optional( z.coerce .bigint() .check( @@ -117050,7 +121189,7 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ }) ) ), - gas_cumulative_between_max_value: z.optional( + log_data_bytes_between_max_value: z.optional( z.coerce .bigint() .check( @@ -117060,90 +121199,74 @@ 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( - z.coerce - .bigint() + log_data_bytes_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_data_bytes_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_topic_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' }) ) ), - error_count_ne: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_lt: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_lte: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_gt: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_gte: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_between_min: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - error_count_between_max_value: z.optional( - z.coerce - .bigint() + log_topic_count_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' }) ) ), - 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+)*$/))), + log_topic_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + log_topic_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), page_size: z.optional( z .int() @@ -117161,9 +121284,9 @@ export const zIntTransactionOpcodeGasServiceListData = z.object({ /** * OK */ -export const zIntTransactionOpcodeGasServiceListResponse = zListIntTransactionOpcodeGasResponse; +export const zIntTransactionReceiptSizeServiceListResponse = zListIntTransactionReceiptSizeResponse; -export const zIntTransactionOpcodeGasServiceGetData = z.object({ +export const zIntTransactionReceiptSizeServiceGetData = z.object({ body: z.optional(z.never()), path: z.object({ block_number: z.coerce @@ -117181,7 +121304,7 @@ export const zIntTransactionOpcodeGasServiceGetData = z.object({ /** * OK */ -export const zIntTransactionOpcodeGasServiceGetResponse = zGetIntTransactionOpcodeGasResponse; +export const zIntTransactionReceiptSizeServiceGetResponse = zGetIntTransactionReceiptSizeResponse; export const zIntTransactionResourceGasServiceListData = z.object({ body: z.optional(z.never()), diff --git a/src/pages/ethereum/execution/gas-profiler/BlockPage.tsx b/src/pages/ethereum/execution/gas-profiler/BlockPage.tsx index 87ed531ff..1c3cb4890 100644 --- a/src/pages/ethereum/execution/gas-profiler/BlockPage.tsx +++ b/src/pages/ethereum/execution/gas-profiler/BlockPage.tsx @@ -11,6 +11,7 @@ import { FireIcon, ArrowsPointingOutIcon, CodeBracketIcon, + DocumentTextIcon, } from '@heroicons/react/24/outline'; import ReactECharts from 'echarts-for-react'; import clsx from 'clsx'; @@ -46,10 +47,13 @@ import { } from './components'; import type { ContractInteractionItem, TopGasItem } from './components'; import { useBlockResourceGas } from './hooks/useBlockResourceGas'; +import { useBlockReceiptSizes } from './hooks/useBlockReceiptSizes'; import { useCallFrameResourceGas } from './hooks/useCallFrameResourceGas'; import { useNetwork } from '@/hooks/useNetwork'; import { CATEGORY_COLORS, CALL_TYPE_COLORS, getOpcodeCategory, getEtherscanBaseUrl, isMainnet } from './utils'; import type { GasProfilerBlockSearch } from './IndexPage.types'; +import type { IntTransactionReceiptSize } from '@/api/types.gen'; +import { formatBytes } from '@/utils'; /** * Available call types for filtering @@ -66,7 +70,7 @@ function formatGas(value: number): string { /** * Sort field type for transactions table */ -type TransactionSortField = 'index' | 'gas' | 'calls' | 'depth'; +type TransactionSortField = 'index' | 'gas' | 'calls' | 'depth' | 'receipt'; /** * Filter and sort transactions based on current settings @@ -75,7 +79,8 @@ function filterAndSortTransactions( transactions: TransactionSummary[], sort: TransactionSortField, sortDir: 'asc' | 'desc', - callTypeFilter?: string + callTypeFilter?: string, + receiptsByTxHash?: Map ): TransactionSummary[] { // Filter by call type if specified let filtered = transactions; @@ -92,6 +97,11 @@ function filterAndSortTransactions( return a.frameCount - b.frameCount; case 'depth': return a.maxDepth - b.maxDepth; + case 'receipt': { + const aBytes = receiptsByTxHash?.get(a.transactionHash)?.receipt_bytes ?? 0; + const bBytes = receiptsByTxHash?.get(b.transactionHash)?.receipt_bytes ?? 0; + return aBytes - bBytes; + } case 'index': default: return a.transactionIndex - b.transactionIndex; @@ -185,6 +195,11 @@ export function BlockPage(): JSX.Element { callFrameId: null, }); + // Fetch receipt sizes for all transactions in the block + const { receiptsByTxHash, totalReceiptBytes } = useBlockReceiptSizes({ + blockNumber: isNaN(blockNumber) ? null : blockNumber, + }); + // Handle sort change (uses local state to avoid scroll reset) const handleSortChange = useCallback( (newSort: TransactionSortField) => { @@ -192,7 +207,7 @@ export function BlockPage(): JSX.Element { // Toggle direction setSortDir(prev => (prev === 'asc' ? 'desc' : 'asc')); } else { - // Default to desc for gas/calls/depth (show highest first), asc for index + // Default to desc for gas/calls/depth/receipt (show highest first), asc for index const defaultDir = newSort === 'index' ? 'asc' : 'desc'; setSortField(newSort); setSortDir(defaultDir); @@ -233,8 +248,8 @@ export function BlockPage(): JSX.Element { // Filter and sort transactions (default to gas desc if not specified) const filteredTransactions = useMemo(() => { if (!data?.transactions) return []; - return filterAndSortTransactions(data.transactions, sortField, sortDir, search.callType); - }, [data?.transactions, sortField, sortDir, search.callType]); + return filterAndSortTransactions(data.transactions, sortField, sortDir, search.callType, receiptsByTxHash); + }, [data?.transactions, sortField, sortDir, search.callType, receiptsByTxHash]); // Calculate total gas for percentage (from all transactions, not filtered) const totalBlockGas = useMemo(() => { @@ -942,6 +957,7 @@ export function BlockPage(): JSX.Element { const canGoPrev = blockNumber > bounds.min; const canGoNext = blockNumber < bounds.max; const failedCount = data.transactions.filter(tx => tx.hasErrors).length; + const hasReceiptData = totalReceiptBytes > 0; return ( @@ -1019,7 +1035,7 @@ export function BlockPage(): JSX.Element { {/* Block Summary - Always visible */} -
+
@@ -1046,6 +1062,35 @@ export function BlockPage(): JSX.Element {
+ {hasReceiptData && ( + +
+
+ +
+
+
+ {formatBytes(totalReceiptBytes)} + +
Receipt Payload Size
+
+ Number of bytes in the canonical encoded receipt value (type byte + RLP receipt) inserted as + the receipts-trie value. Does not include trie node/path/proof overhead. +
+ + } + /> +
+
Receipt Payload
+
+
+ + )} +
@@ -1360,6 +1405,23 @@ export function BlockPage(): JSX.Element { > % + {hasReceiptData && ( + handleSortChange('receipt')} + className={clsx( + 'cursor-pointer px-3 py-3.5 text-right text-sm font-semibold whitespace-nowrap transition-colors hover:text-primary', + sortField === 'receipt' ? 'text-primary' : 'text-foreground' + )} + > + + Receipt + {sortField === 'receipt' && ( + {sortDir === 'asc' ? '↑' : '↓'} + )} + + + )} handleSortChange('calls')} @@ -1395,12 +1457,15 @@ export function BlockPage(): JSX.Element { {filteredTransactions.slice(0, visibleCount).map(tx => { const gasPercentage = totalBlockGas > 0 ? (tx.totalGasUsed / totalBlockGas) * 100 : 0; + const receiptData = receiptsByTxHash.get(tx.transactionHash); return ( ); })} diff --git a/src/pages/ethereum/execution/gas-profiler/HomePage.tsx b/src/pages/ethereum/execution/gas-profiler/HomePage.tsx index 386b15cfc..4df81fde3 100644 --- a/src/pages/ethereum/execution/gas-profiler/HomePage.tsx +++ b/src/pages/ethereum/execution/gas-profiler/HomePage.tsx @@ -27,14 +27,19 @@ import { fctOpcodeOpsDailyServiceList, fctOpcodeGasByOpcodeHourlyServiceList, fctOpcodeGasByOpcodeDailyServiceList, + fctExecutionReceiptSizeHourlyServiceList, + fctExecutionReceiptSizeDailyServiceList, } from '@/api/sdk.gen'; import type { FctOpcodeOpsHourly, FctOpcodeOpsDaily, FctOpcodeGasByOpcodeHourly, FctOpcodeGasByOpcodeDaily, + FctExecutionReceiptSizeHourly, + FctExecutionReceiptSizeDaily, } from '@/api/types.gen'; import { fetchAllPages } from '@/utils/api-pagination'; +import { formatBytes } from '@/utils'; import { useRecentBlocks } from './hooks/useRecentBlocks'; import { useGasProfilerBounds } from './hooks/useGasProfilerBounds'; import { GasProfilerSkeleton, OpcodeAnalysis } from './components'; @@ -161,6 +166,13 @@ function formatCompact(value: number): string { return value.toString(); } +/** Format a byte band range for display */ +function formatBytesBand(lower: number | undefined, upper: number | undefined): string { + const l = lower ?? 0; + const u = upper ?? 0; + return `${formatBytes(l)} – ${formatBytes(u)}`; +} + /** * Validate if string is a valid block number */ @@ -301,6 +313,43 @@ export function HomePage(): JSX.Element { enabled: isDaily, }); + // Receipt Size Per Block Queries - with pagination + const receiptSizeHourlyQuery = useQuery({ + queryKey: ['gas-profiler', 'receipt-size-hourly', startTimestamp, config.pageSize], + queryFn: ({ signal }) => + fetchAllPages( + fctExecutionReceiptSizeHourlyServiceList, + { + query: { + hour_start_date_time_gte: startTimestamp, + order_by: 'hour_start_date_time asc', + page_size: config.pageSize, + }, + }, + 'fct_execution_receipt_size_hourly', + signal + ), + enabled: !isDaily, + }); + + const receiptSizeDailyQuery = useQuery({ + queryKey: ['gas-profiler', 'receipt-size-daily', config.pageSize], + queryFn: ({ signal }) => + fetchAllPages( + fctExecutionReceiptSizeDailyServiceList, + { + query: { + day_start_date_like: '20%', + order_by: 'day_start_date desc', + page_size: config.pageSize, + }, + }, + 'fct_execution_receipt_size_daily', + signal + ), + enabled: isDaily, + }); + // Opcode ops records (fetchAllPages returns array directly) // Filter by time period for daily data const opcodeOpsRecords = useMemo(() => { @@ -316,6 +365,19 @@ export function HomePage(): JSX.Element { return opcodeOpsHourlyQuery.data; }, [isDaily, opcodeOpsDailyQuery.data, opcodeOpsHourlyQuery.data, config.days]); + // Receipt size records - hourly/daily switching with client-side date filtering + const receiptSizeRecords = useMemo(() => { + if (isDaily) { + const allRecords = [...(receiptSizeDailyQuery.data ?? [])].reverse(); + if (config.days === null) return allRecords; + const cutoffDate = new Date(); + cutoffDate.setDate(cutoffDate.getDate() - config.days); + const cutoffStr = cutoffDate.toISOString().split('T')[0]; + return allRecords.filter(r => (r.day_start_date ?? '') >= cutoffStr); + } + return receiptSizeHourlyQuery.data; + }, [isDaily, receiptSizeDailyQuery.data, receiptSizeHourlyQuery.data, config.days]); + // Aggregate opcodes for OpcodeAnalysis component (fetchAllPages returns array directly) // Filter by time period for daily data const opcodeStats = useMemo(() => { @@ -718,12 +780,214 @@ export function HomePage(): JSX.Element { [opcodeOpsRecords, opcodesPerSecondConfig, isDaily, timePeriod] ); + // Receipt Size Per Block chart config + const receiptSizeConfig = useMemo(() => { + if (!receiptSizeRecords?.length) return null; + + const labels: string[] = []; + const avgValues: (number | null)[] = []; + const movingAvgValues: (number | null)[] = []; + const medianValues: (number | null)[] = []; + const minValues: (number | null)[] = []; + const maxValues: (number | null)[] = []; + const p5Values: (number | null)[] = []; + const p95Values: (number | null)[] = []; + const lowerBandValues: (number | null)[] = []; + const upperBandValues: (number | null)[] = []; + + for (const r of receiptSizeRecords) { + let label: string; + if (isDaily) { + label = (r as FctExecutionReceiptSizeDaily).day_start_date ?? ''; + } else { + const ts = (r as FctExecutionReceiptSizeHourly).hour_start_date_time ?? 0; + const date = new Date(ts * 1000); + if (timePeriod === '24h') { + label = date.toLocaleTimeString('en-US', { + hour: 'numeric', + timeZone: 'UTC', + }); + } else if (timePeriod === '72h') { + label = date.toLocaleDateString('en-US', { + month: 'short', + day: 'numeric', + hour: 'numeric', + timeZone: 'UTC', + }); + } else { + label = date.toLocaleDateString('en-US', { + month: 'short', + day: 'numeric', + year: '2-digit', + timeZone: 'UTC', + }); + } + } + + labels.push(label); + avgValues.push(r.avg_receipt_bytes_per_block ?? null); + movingAvgValues.push(r.moving_avg_receipt_bytes_per_block ?? null); + medianValues.push(r.p50_receipt_bytes_per_block ?? null); + minValues.push(r.min_receipt_bytes_per_block ?? null); + maxValues.push(r.max_receipt_bytes_per_block ?? null); + p5Values.push(r.p05_receipt_bytes_per_block ?? null); + p95Values.push(r.p95_receipt_bytes_per_block ?? null); + lowerBandValues.push(r.lower_band_receipt_bytes_per_block ?? null); + upperBandValues.push(r.upper_band_receipt_bytes_per_block ?? null); + } + + return { + labels, + series: [ + createStatisticSeries('Average', avgValues, { + color: '#10b981', + lineWidth: 2.5, + group: 'Statistics', + }), + createStatisticSeries('Moving Avg', movingAvgValues, { + color: '#06b6d4', + lineWidth: 2, + group: 'Statistics', + }), + createStatisticSeries('Median', medianValues, { + color: '#a855f7', + lineWidth: 1.5, + lineStyle: 'dotted', + group: 'Statistics', + }), + ...createBandSeries('Bollinger', 'receipt-bollinger', lowerBandValues, upperBandValues, { + color: '#f59e0b', + opacity: 0.15, + group: 'Bands', + initiallyVisible: false, + }), + ...createBandSeries('P5/P95', 'receipt-percentile', p5Values, p95Values, { + color: '#6366f1', + opacity: 0.1, + group: 'Bands', + }), + ...createBandSeries('Min/Max', 'receipt-minmax', minValues, maxValues, { + color: '#64748b', + opacity: 0.06, + group: 'Bands', + }), + ], + }; + }, [receiptSizeRecords, isDaily, timePeriod]); + + // Receipt Size tooltip formatter + const receiptTooltipFormatter = useCallback( + (params: unknown): string => { + if (!receiptSizeRecords?.length || !receiptSizeConfig) return ''; + + const recordsByKey = new Map(); + for (const r of receiptSizeRecords) { + let key: string; + if (isDaily) { + key = (r as FctExecutionReceiptSizeDaily).day_start_date ?? ''; + } else { + const ts = (r as FctExecutionReceiptSizeHourly).hour_start_date_time ?? 0; + const date = new Date(ts * 1000); + if (timePeriod === '24h') { + key = date.toLocaleTimeString('en-US', { + hour: 'numeric', + timeZone: 'UTC', + }); + } else if (timePeriod === '72h') { + key = date.toLocaleDateString('en-US', { + month: 'short', + day: 'numeric', + hour: 'numeric', + timeZone: 'UTC', + }); + } else { + key = date.toLocaleDateString('en-US', { + month: 'short', + day: 'numeric', + year: '2-digit', + timeZone: 'UTC', + }); + } + } + recordsByKey.set(key, r); + } + + const dataPoints = Array.isArray(params) ? params : [params]; + if (!dataPoints.length) return ''; + + const firstPoint = dataPoints[0] as { dataIndex?: number }; + if (firstPoint.dataIndex === undefined) return ''; + + const timeKey = receiptSizeConfig.labels[firstPoint.dataIndex]; + if (!timeKey) return ''; + + const record = recordsByKey.get(timeKey); + if (!record) return ''; + + const dateValue = isDaily + ? ((record as FctExecutionReceiptSizeDaily).day_start_date ?? '') + : ((record as FctExecutionReceiptSizeHourly).hour_start_date_time ?? 0); + const dateStr = formatTooltipDate(dateValue, isDaily); + + const sections: TooltipSection[] = [ + { + title: 'STATISTICS', + items: [ + { color: '#10b981', label: 'Average', value: formatBytes(record.avg_receipt_bytes_per_block ?? 0) }, + { + color: '#06b6d4', + label: 'Moving Avg', + value: formatBytes(record.moving_avg_receipt_bytes_per_block ?? 0), + }, + { + color: '#a855f7', + label: 'Median', + value: formatBytes(record.p50_receipt_bytes_per_block ?? 0), + style: 'dotted', + }, + ], + }, + { + title: 'BANDS', + items: [ + { + color: '#f59e0b', + label: 'Bollinger', + value: formatBytesBand( + record.lower_band_receipt_bytes_per_block, + record.upper_band_receipt_bytes_per_block + ), + style: 'area', + }, + { + color: '#6366f1', + label: 'P5/P95', + value: formatBytesBand(record.p05_receipt_bytes_per_block, record.p95_receipt_bytes_per_block), + style: 'area', + }, + { + color: '#64748b', + label: 'Min/Max', + value: formatBytesBand(record.min_receipt_bytes_per_block, record.max_receipt_bytes_per_block), + style: 'area', + }, + ], + }, + ]; + + return buildTooltipHtml(dateStr, sections); + }, + [receiptSizeRecords, receiptSizeConfig, isDaily, timePeriod] + ); + // Loading states const isOpcodeOpsLoading = isDaily ? opcodeOpsDailyQuery.isLoading : opcodeOpsHourlyQuery.isLoading; const isOpcodeGasLoading = isDaily ? opcodeGasDailyQuery.isLoading : opcodeGasHourlyQuery.isLoading; + const isReceiptSizeLoading = isDaily ? receiptSizeDailyQuery.isLoading : receiptSizeHourlyQuery.isLoading; + if (boundsLoading) { return ( @@ -881,7 +1145,7 @@ export function HomePage(): JSX.Element {
)}
+ + {/* Receipt Size Per Block */} +
+ + {({ inModal }) => + isReceiptSizeLoading ? ( +
+
Loading receipt size data...
+
+ ) : receiptSizeConfig ? ( + formatBytes(value), + }} + height={inModal ? 600 : 320} + showLegend + legendPosition="top" + enableDataZoom + tooltipFormatter={receiptTooltipFormatter} + markLines={showAnnotations ? forkMarkLines : []} + syncGroup={inModal ? undefined : 'gas-profiler'} + /> + ) : ( +
No data available
+ ) + } + +
); } diff --git a/src/pages/ethereum/execution/gas-profiler/TransactionPage.tsx b/src/pages/ethereum/execution/gas-profiler/TransactionPage.tsx index 5017a3295..2a4d451cd 100644 --- a/src/pages/ethereum/execution/gas-profiler/TransactionPage.tsx +++ b/src/pages/ethereum/execution/gas-profiler/TransactionPage.tsx @@ -13,6 +13,7 @@ import { DocumentTextIcon, } from '@heroicons/react/24/outline'; import ReactECharts from 'echarts-for-react'; +import clsx from 'clsx'; import { Tab } from '@/components/Navigation/Tab'; import { GasTooltip } from '@/components/DataDisplay/GasTooltip'; import { Container } from '@/components/Layout/Container'; @@ -42,6 +43,8 @@ import { import type { TopGasItem, CallFrameData } from './components'; import { getCallLabel } from './hooks/useTransactionGasData'; import { useCallFrameResourceGas } from './hooks/useCallFrameResourceGas'; +import { useTransactionReceiptSize } from './hooks/useTransactionReceiptSize'; +import { formatBytes } from '@/utils'; import { useNetwork } from '@/hooks/useNetwork'; import { CATEGORY_COLORS, @@ -129,6 +132,12 @@ export function TransactionPage(): JSX.Element { callFrameId: null, }); + // Fetch receipt size data for this transaction + const { data: receiptSize } = useTransactionReceiptSize({ + transactionHash: txHash, + blockNumber, + }); + // Derive badge stats from full opcode data (SSTORE, SLOAD, LOG*, CREATE*, SELFDESTRUCT) const callFrameOpcodeStats = useMemo((): Map => { const statsMap = new Map(); @@ -782,7 +791,12 @@ export function TransactionPage(): JSX.Element {
{/* Quick Stats Row - Always visible */} -
+
@@ -819,6 +833,35 @@ export function TransactionPage(): JSX.Element {
+ {receiptSize?.receipt_bytes && ( + +
+
+ +
+
+
+ {formatBytes(receiptSize.receipt_bytes)} + +
Receipt Payload Size
+
+ Number of bytes in the canonical encoded receipt value (type byte + RLP receipt) inserted as + the receipts-trie value. Does not include trie node/path/proof overhead. +
+ + } + /> +
+
Receipt Payload
+
+
+ + )} +
@@ -922,6 +965,106 @@ export function TransactionPage(): JSX.Element {
+ {/* Receipt Payload Breakdown - only show when data exists */} + {receiptSize && + (() => { + const totalBytes = receiptSize.receipt_bytes ?? 0; + const logDataBytes = receiptSize.log_data_bytes ?? 0; + // Each topic is 32 bytes + const logTopicBytes = (receiptSize.log_topic_count ?? 0) * 32; + const overheadBytes = Math.max(0, totalBytes - logDataBytes - logTopicBytes); + const logDataPct = totalBytes > 0 ? (logDataBytes / totalBytes) * 100 : 0; + const logTopicPct = totalBytes > 0 ? (logTopicBytes / totalBytes) * 100 : 0; + const overheadPct = totalBytes > 0 ? (overheadBytes / totalBytes) * 100 : 0; + + return ( + + {/* Header */} +
+

+ Receipt Payload + +
Receipt Payload Size
+
+ Number of bytes in the canonical encoded receipt value (type byte + RLP receipt) + inserted as the receipts-trie value. Does not include trie node/path/proof overhead. +
+ + } + /> +

+ + {receiptSize.log_count ?? 0} log{(receiptSize.log_count ?? 0) !== 1 ? 's' : ''} emitted + +
+ + {/* Proportional bar */} +
+
+ + {formatBytes(totalBytes)} + +
+ + {/* Stacked bar */} +
+ {logDataPct > 0 && ( +
+ )} + {logTopicPct > 0 && ( +
+ )} + {overheadPct > 0 && ( +
+ )} +
+ + {/* Legend */} +
+
+ + + Log Data {formatBytes(logDataBytes)} + +
+
+ + + Log Topics{' '} + + {receiptSize.log_topic_count ?? 0} ({formatBytes(logTopicBytes)}) + + +
+
+ + + RLP + Status{' '} + {formatBytes(overheadBytes)} + +
+
+
+ + ); + })()} + {/* Call Tree or Simple Transfer Message */} {isSimpleTransfer ? ( diff --git a/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.tsx b/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.tsx index ccebee693..190346d55 100644 --- a/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.tsx +++ b/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.tsx @@ -2,6 +2,7 @@ import { type JSX, useCallback } from 'react'; import { useNavigate } from '@tanstack/react-router'; import { ExclamationTriangleIcon } from '@heroicons/react/24/outline'; import clsx from 'clsx'; +import { formatBytes } from '@/utils'; import type { TransactionSummaryCardProps } from './TransactionSummaryCard.types'; /** @@ -48,6 +49,8 @@ export function TransactionSummaryCard({ transaction, blockNumber, gasPercentage, + receiptBytes, + showReceiptColumn, }: TransactionSummaryCardProps): JSX.Element { const callTypeStyles = getCallTypeStyles(transaction.rootCallType); const navigate = useNavigate(); @@ -122,6 +125,13 @@ export function TransactionSummaryCard({
+ {/* Receipt size */} + {showReceiptColumn && ( + + {receiptBytes != null ? formatBytes(receiptBytes) : '—'} + + )} + {/* Calls (frame count) */} {transaction.frameCount} diff --git a/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.types.ts b/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.types.ts index 552247889..1b3699cc4 100644 --- a/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.types.ts +++ b/src/pages/ethereum/execution/gas-profiler/components/TransactionSummaryCard/TransactionSummaryCard.types.ts @@ -10,4 +10,8 @@ export interface TransactionSummaryCardProps { blockNumber: number; /** Gas usage as percentage of block total */ gasPercentage: number; + /** Receipt size in bytes (from int_transaction_receipt_size) */ + receiptBytes?: number | null; + /** Whether to show the receipt column (only when receipt data exists for the block) */ + showReceiptColumn?: boolean; } diff --git a/src/pages/ethereum/execution/gas-profiler/hooks/index.ts b/src/pages/ethereum/execution/gas-profiler/hooks/index.ts index 0ae49a017..57971d855 100644 --- a/src/pages/ethereum/execution/gas-profiler/hooks/index.ts +++ b/src/pages/ethereum/execution/gas-profiler/hooks/index.ts @@ -35,3 +35,7 @@ export { useTransactionResourceGas } from './useTransactionResourceGas'; export type { UseTransactionResourceGasOptions, UseTransactionResourceGasResult } from './useTransactionResourceGas'; export { useCallFrameResourceGas } from './useCallFrameResourceGas'; export type { UseCallFrameResourceGasOptions, UseCallFrameResourceGasResult } from './useCallFrameResourceGas'; +export { useBlockReceiptSizes } from './useBlockReceiptSizes'; +export type { UseBlockReceiptSizesOptions, UseBlockReceiptSizesResult } from './useBlockReceiptSizes'; +export { useTransactionReceiptSize } from './useTransactionReceiptSize'; +export type { UseTransactionReceiptSizeOptions, UseTransactionReceiptSizeResult } from './useTransactionReceiptSize'; diff --git a/src/pages/ethereum/execution/gas-profiler/hooks/useBlockReceiptSizes.ts b/src/pages/ethereum/execution/gas-profiler/hooks/useBlockReceiptSizes.ts new file mode 100644 index 000000000..81b6eb8cf --- /dev/null +++ b/src/pages/ethereum/execution/gas-profiler/hooks/useBlockReceiptSizes.ts @@ -0,0 +1,70 @@ +import { useMemo } from 'react'; +import { useQuery } from '@tanstack/react-query'; +import { intTransactionReceiptSizeServiceList } from '@/api/sdk.gen'; +import type { IntTransactionReceiptSize } from '@/api/types.gen'; +import { useNetwork } from '@/hooks/useNetwork'; +import { fetchAllPages } from '@/utils/api-pagination'; + +export interface UseBlockReceiptSizesOptions { + blockNumber: number | null; +} + +export interface UseBlockReceiptSizesResult { + /** Map of transaction hash → receipt size data for O(1) lookup */ + receiptsByTxHash: Map; + /** Total receipt bytes across all transactions in the block */ + totalReceiptBytes: number; + isLoading: boolean; + error: Error | null; +} + +/** + * Hook to fetch all receipt sizes for a block. + * Uses `int_transaction_receipt_size` API with `block_number_eq` filter. + */ +export function useBlockReceiptSizes({ blockNumber }: UseBlockReceiptSizesOptions): UseBlockReceiptSizesResult { + const { currentNetwork } = useNetwork(); + + const enabled = !!currentNetwork && blockNumber !== null && !isNaN(blockNumber); + + const { data, isLoading, error } = useQuery({ + queryKey: ['blockReceiptSizes', blockNumber], + queryFn: ({ signal }) => + fetchAllPages( + intTransactionReceiptSizeServiceList, + { + query: { + block_number_eq: blockNumber!, + page_size: 10000, + }, + }, + 'int_transaction_receipt_size', + signal + ), + enabled, + staleTime: 5 * 60 * 1000, + }); + + const receiptsByTxHash = useMemo(() => { + const map = new Map(); + if (!data) return map; + for (const item of data) { + if (item.transaction_hash) { + map.set(item.transaction_hash, item); + } + } + return map; + }, [data]); + + const totalReceiptBytes = useMemo(() => { + if (!data) return 0; + return data.reduce((sum, item) => sum + (item.receipt_bytes ?? 0), 0); + }, [data]); + + return { + receiptsByTxHash, + totalReceiptBytes, + isLoading, + error: error as Error | null, + }; +} diff --git a/src/pages/ethereum/execution/gas-profiler/hooks/useTransactionReceiptSize.ts b/src/pages/ethereum/execution/gas-profiler/hooks/useTransactionReceiptSize.ts new file mode 100644 index 000000000..4d1722d6f --- /dev/null +++ b/src/pages/ethereum/execution/gas-profiler/hooks/useTransactionReceiptSize.ts @@ -0,0 +1,58 @@ +import { useMemo } from 'react'; +import { useQuery } from '@tanstack/react-query'; +import { intTransactionReceiptSizeServiceListOptions } from '@/api/@tanstack/react-query.gen'; +import type { IntTransactionReceiptSize } from '@/api/types.gen'; +import { useNetwork } from '@/hooks/useNetwork'; + +export interface UseTransactionReceiptSizeOptions { + transactionHash: string | null; + blockNumber: number | null; +} + +export interface UseTransactionReceiptSizeResult { + /** Receipt size data for the transaction */ + data: IntTransactionReceiptSize | null; + isLoading: boolean; + error: Error | null; +} + +/** + * Hook to fetch receipt size data for a single transaction. + * Uses `int_transaction_receipt_size` API with `transaction_hash_eq` filter. + */ +export function useTransactionReceiptSize({ + transactionHash, + blockNumber, +}: UseTransactionReceiptSizeOptions): UseTransactionReceiptSizeResult { + const { currentNetwork } = useNetwork(); + + const enabled = !!currentNetwork && !!transactionHash; + + const { + data: response, + isLoading, + error, + } = useQuery({ + ...intTransactionReceiptSizeServiceListOptions({ + query: { + transaction_hash_eq: transactionHash!, + ...(blockNumber !== null && { block_number_eq: blockNumber }), + page_size: 1, + }, + }), + enabled, + staleTime: 5 * 60 * 1000, + }); + + const data = useMemo(() => { + const items = response?.int_transaction_receipt_size; + if (!items?.length) return null; + return items[0]; + }, [response]); + + return { + data, + isLoading, + error: error as Error | null, + }; +} diff --git a/src/utils/number.ts b/src/utils/number.ts index ea46a8451..91afe72ef 100644 --- a/src/utils/number.ts +++ b/src/utils/number.ts @@ -54,3 +54,20 @@ export function formatSlot(slot: number): string { export function formatEpoch(epoch: number): string { return epoch.toString(); } + +/** + * Format byte values to human-readable string + * + * @param bytes - Number of bytes to format + * @returns Formatted string with appropriate unit (B, KB, MB) + * + * @example + * formatBytes(512) // "512 B" + * formatBytes(2048) // "2.0 KB" + * formatBytes(1572864) // "1.5 MB" + */ +export function formatBytes(bytes: number): string { + if (bytes < 1024) return `${bytes} B`; + if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`; + return `${(bytes / (1024 * 1024)).toFixed(1)} MB`; +}