import { type Context } from 'hono';
import { Hex } from 'ox';
import * as z from 'zod/mini';
import type * as App from '../../../App.js';
import * as Response from '../../../internal/Response.js';
import * as Schema from '../../../internal/Schema.js';
/** The EVM block tags accepted by the `:block` selector. */
declare const blockTags: readonly ['latest', 'finalized'];
/** Zod schemas owned by the block handlers. */
export declare namespace schema {
    /** The verbatim JSON-RPC payloads, surfaced under each resource's `rpc` field. */
    namespace Rpc {
        /** A JSON-RPC block, passed through verbatim. */
        const Block: z.ZodMiniObject<{
            baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
            difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
            gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
            gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
            hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
            number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            size: z.ZodMiniTemplateLiteral<`0x${string}`>;
            stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
            totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
            withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
            withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
        }, z.core.$loose>;
    }
    /**
     * Metadata for a block: the verbatim JSON-RPC block (always present). Held in
     * a `meta` envelope so future opt-in `include` resources (e.g. embedded
     * transactions) can layer in without breaking the response shape.
     */
    const BlockMeta: z.ZodMiniObject<{
        rpc: z.ZodMiniObject<{
            baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
            difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
            gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
            gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
            hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
            number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            size: z.ZodMiniTemplateLiteral<`0x${string}`>;
            stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
            totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
            transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
            withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
            withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
        }, z.core.$loose>;
    }, z.core.$strip>;
    /**
     * A humanized block: decimal-string amounts, ISO 8601 timestamps, and plain
     * numbers for block fields. The verbatim JSON-RPC payload is always
     * available under `meta.rpc`. Transactions are omitted from the response;
     * clients filter `GET /v1/transactions` to this block number.
     */
    const Block: z.ZodMiniObject<{
        baseFeePerGas: z.ZodMiniNullable<z.ZodMiniString<string>>;
        gasLimit: z.ZodMiniNumber<number>;
        gasUsed: z.ZodMiniNumber<number>;
        hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        meta: z.ZodMiniObject<{
            rpc: z.ZodMiniObject<{
                baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
                difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
                gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
                gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
                hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
                miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
                number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                size: z.ZodMiniTemplateLiteral<`0x${string}`>;
                stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
                totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
                withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
                withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
            }, z.core.$loose>;
        }, z.core.$strip>;
        miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        number: z.ZodMiniNumber<number>;
        parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        size: z.ZodMiniNumber<number>;
        timestamp: z.ZodMiniISODateTime;
        transactionCount: z.ZodMiniNumber<number>;
    }, z.core.$strip>;
    /**
     * A lightweight block row, returned by the `/blocks` list endpoint. Full
     * fields (parentHash, miner, gasUsed/gasLimit, …) would require one RPC
     * roundtrip per row; the list endpoint stays cheap and clients fetch
     * `/blocks/:block` for individual blocks they care about. The block hash is
     * selected from the index so `id` stays tied to the resolved block identity.
     */
    const BlockSummary: z.ZodMiniObject<{
        hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        number: z.ZodMiniNumber<number>;
        timestamp: z.ZodMiniISODateTime;
        transactionCount: z.ZodMiniNumber<number>;
    }, z.core.$strip>;
    /** Schemas for the getBlocks operation. */
    namespace getBlocks {
        /** Query parameters for `GET /blocks`. */
        const Query: z.ZodMiniObject<{
            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
                mainnet: "mainnet";
                testnet: "testnet";
            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniPipe<z.ZodMiniNumber<unknown>, z.ZodMiniTransform<number, number>>]>, z.ZodMiniNumber<number>>>;
            cursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
            limit: z.ZodMiniDefault<z.ZodMiniPipe<z.ZodMiniNumber<unknown>, z.ZodMiniTransform<number, number>>>;
            order: z.ZodMiniDefault<z.ZodMiniEnum<{
                asc: "asc";
                desc: "desc";
            }>>;
            page: z.ZodMiniOptional<z.ZodMiniNumber<unknown>>;
        }, z.core.$strict>;
        /** Page of lightweight block rows, including empty blocks. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniArray<z.ZodMiniObject<{
                hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                number: z.ZodMiniNumber<number>;
                timestamp: z.ZodMiniISODateTime;
                transactionCount: z.ZodMiniNumber<number>;
            }, z.core.$strip>>;
            nextCursor: z.ZodMiniNullable<z.ZodMiniString<string>>;
        }, z.core.$strip>;
    }
    /** Schemas for the getBlock operation. */
    namespace getBlock {
        /**
         * Path parameter for block requests. Resolves a single block from any of:
         * a block tag (`latest`, `finalized`); a decimal or `0x`-prefixed hex block
         * number; a `0x`-prefixed 32-byte block hash; or an ISO 8601 timestamp
         * (`2023-11-14T22:13:20Z`), which resolves to the first block at or after
         * that instant.
         */
        const Params: z.ZodMiniObject<{
            block: z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
                finalized: "finalized";
                latest: "latest";
            }>, z.ZodMiniString<string>, z.ZodMiniISODateTime]>;
        }, z.core.$strip>;
        /** Query parameters for `GET /blocks/:block`. */
        const Query: z.ZodMiniObject<{
            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
                mainnet: "mainnet";
                testnet: "testnet";
            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniPipe<z.ZodMiniNumber<unknown>, z.ZodMiniTransform<number, number>>]>, z.ZodMiniNumber<number>>>;
        }, z.core.$strict>;
        /** A humanized block, with the verbatim JSON-RPC payload under `meta.rpc`. */
        const Response: z.ZodMiniObject<{
            baseFeePerGas: z.ZodMiniNullable<z.ZodMiniString<string>>;
            gasLimit: z.ZodMiniNumber<number>;
            gasUsed: z.ZodMiniNumber<number>;
            hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            meta: z.ZodMiniObject<{
                rpc: z.ZodMiniObject<{
                    baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
                    difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                    extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
                    gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
                    gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
                    hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                    logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
                    miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                    mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                    nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
                    number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                    parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                    receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                    sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                    size: z.ZodMiniTemplateLiteral<`0x${string}`>;
                    stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                    timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
                    totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                    transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                    transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                    uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
                    withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
                    withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
                }, z.core.$loose>;
            }, z.core.$strip>;
            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            number: z.ZodMiniNumber<number>;
            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            size: z.ZodMiniNumber<number>;
            timestamp: z.ZodMiniISODateTime;
            transactionCount: z.ZodMiniNumber<number>;
        }, z.core.$strip>;
    }
    /**
     * Schemas for the legacy `getBlockByTimestamp` compatibility operation
     * (`GET /chains/:chainId/blocks/by-timestamp`). Hidden from the docs; kept to
     * keep pre-existing clients of the prior Tempo API working unchanged.
     */
    namespace getBlockByTimestamp {
        /** Path parameters: the numeric Tempo chain id. */
        const Params: z.ZodMiniObject<{
            chainId: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
                mainnet: "mainnet";
                testnet: "testnet";
            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniPipe<z.ZodMiniNumber<unknown>, z.ZodMiniTransform<number, number>>]>, z.ZodMiniNumber<number>>;
        }, z.core.$strip>;
        /** Query parameters: a required unix timestamp and the search direction. */
        const Query: z.ZodMiniObject<{
            closest: z.ZodMiniDefault<z.ZodMiniEnum<{
                after: "after";
                before: "before";
            }>>;
            timestamp: z.ZodMiniNumber<unknown>;
        }, z.core.$strict>;
        /** The legacy response envelope: `{ block: { blockNumber, blockTimestamp } }`. */
        const Response: z.ZodMiniObject<{
            block: z.ZodMiniObject<{
                blockNumber: z.ZodMiniNumber<number>;
                blockTimestamp: z.ZodMiniNumber<number>;
            }, z.core.$strip>;
        }, z.core.$strip>;
    }
}
/** Creates block handlers. */
export declare function blocks(): import("hono/hono-base").HonoBase<App.Environment, {
    "/v1/blocks": {
        $get: {
            output: null;
            outputFormat: "body";
            status: 402;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "query_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_malformed";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_invalid" | "api_key_missing";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 401;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 403;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "payment_required" | "rate_limit_exceeded";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 429;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                data: {
                    hash: `0x${string}`;
                    id: `0x${string}`;
                    number: number;
                    timestamp: string;
                    transactionCount: number;
                }[];
                nextCursor: string | null;
            };
            outputFormat: "json";
            status: 200;
            input: {
                query?: {
                    chainId?: string | string[];
                    cursor?: string | string[];
                    limit?: string | string[];
                    order?: string | string[];
                    page?: string | string[];
                } | undefined;
            };
        };
    };
} & {
    "/v1/blocks/:block": {
        $get: {
            output: null;
            outputFormat: "body";
            status: 402;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "query_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_malformed";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_invalid" | "api_key_missing";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 401;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 403;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "payment_required" | "rate_limit_exceeded";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 429;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "block_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "block_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                baseFeePerGas: string | null;
                gasLimit: number;
                gasUsed: number;
                hash: `0x${string}`;
                id: `0x${string}`;
                meta: {
                    rpc: {
                        [x: string]: import("hono/utils/types").JSONValue;
                        baseFeePerGas?: `0x${string}` | null | undefined;
                        difficulty?: `0x${string}` | undefined;
                        extraData?: `0x${string}` | undefined;
                        gasLimit: `0x${string}`;
                        gasUsed: `0x${string}`;
                        hash: `0x${string}` | null;
                        logsBloom?: `0x${string}` | null | undefined;
                        miner: `0x${string}`;
                        mixHash?: `0x${string}` | undefined;
                        nonce?: `0x${string}` | null | undefined;
                        number: `0x${string}` | null;
                        parentHash: `0x${string}`;
                        receiptsRoot: `0x${string}`;
                        sha3Uncles?: `0x${string}` | undefined;
                        size: `0x${string}`;
                        stateRoot: `0x${string}`;
                        timestamp: `0x${string}`;
                        totalDifficulty?: `0x${string}` | undefined;
                        transactions: `0x${string}`[];
                        transactionsRoot: `0x${string}`;
                        uncles?: `0x${string}`[] | undefined;
                        withdrawals?: {
                            [x: string]: import("hono/utils/types").JSONValue;
                        }[] | undefined;
                        withdrawalsRoot?: `0x${string}` | undefined;
                    };
                };
                miner: `0x${string}`;
                number: number;
                parentHash: `0x${string}`;
                size: number;
                timestamp: string;
                transactionCount: number;
            };
            outputFormat: "json";
            status: 200;
            input: {
                param: {
                    block: string;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                } | undefined;
            };
        };
    };
}, "/", "/v1/blocks/:block">;
/**
 * Mounts the hidden legacy `GET /chains/:chainId/blocks/by-timestamp`
 * compatibility route at the app root. The prior Tempo API exposed this shape
 * (chain id in the path, a required unix `timestamp`, and a `closest` direction)
 * and returned `{ block: { blockNumber, blockTimestamp } }`; this preserves it
 * so existing clients keep working while the canonical surface is
 * `GET /v1/blocks/:block` with an ISO 8601 selector.
 *
 * Like the original it searches a ±{@link byTimestampWindowSeconds}s window and
 * returns `404` when no indexed block falls within it. A local supported-chain
 * check keeps standalone composition safe.
 */
export declare function blocksByTimestampCompat(): import("hono/hono-base").HonoBase<App.Environment, {
    "/chains/:chainId/blocks/by-timestamp": {
        $get: {
            output: null;
            outputFormat: "body";
            status: 402;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "chain_id_unsupported";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "query_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "api_key_malformed";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "api_key_invalid" | "api_key_missing";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 401;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 403;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "payment_required" | "rate_limit_exceeded";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 429;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "block_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        } | {
            output: {
                block: {
                    blockNumber: number;
                    blockTimestamp: number;
                };
            };
            outputFormat: "json";
            status: 200;
            input: {
                param: {
                    chainId: string;
                };
            } & {
                query: {
                    closest?: string | string[];
                    timestamp: string | string[];
                };
            };
        };
    };
}, "/", "/chains/:chainId/blocks/by-timestamp">;
export declare namespace findBlockByTimestamp {
    type Options = {
        chainId: z.output<typeof Schema.ChainId>;
        closest: 'before' | 'after';
        timestamp: number;
    };
}
/**
 * Parses a `:block` path parameter, dispatching by shape. Returns the
 * discriminated identifier, or `undefined` when the input matches no known
 * shape (the schema should have caught this earlier; this guards the type at
 * the use site).
 *
 * Selectors are unambiguous by shape: a block tag is a fixed keyword; the
 * 66-char `0x`-prefixed length identifies a 32-byte hash; any other
 * `0x`-prefixed hex (or plain decimal) is a block number; and an ISO 8601
 * timestamp (validated with the same {@link blockTimestamp} schema as the
 * route) is resolved to its UTC instant.
 */
export declare function parseBlockIdentifier(value: string): parseBlockIdentifier.Result | undefined;
export declare namespace parseBlockIdentifier {
    /** An EVM block tag accepted by the `:block` selector. */
    type BlockTag = (typeof blockTags)[number];
    /** A parsed block identifier, dispatching by shape. */
    type Result = {
        kind: 'tag';
        tag: BlockTag;
    } | {
        kind: 'hash';
        hash: Hex.Hex;
    } | {
        kind: 'number';
        number: bigint;
    } | {
        kind: 'timestamp';
        iso: string;
    };
}
/**
 * Lists blocks from the indexer. Reads every block from the `blocks` table
 * (so empty blocks are included) and resolves transaction counts via a
 * second narrow `txs` query keyed to the page's block numbers.
 */
export declare function listBlocks(c: Context<App.Environment>, options: listBlocks.Options): Promise<{
    data: {
        hash: `0x${string}`;
        id: `0x${string}`;
        number: number;
        timestamp: string;
        transactionCount: number;
    }[];
    nextCursor: string | null;
}>;
export declare namespace listBlocks {
    type Options = {
        chainId: z.output<typeof Schema.ChainId>;
        /** Opaque keyset cursor anchoring the page; omit for the head page. */
        cursor?: string | undefined;
        limit: number;
        /** 1-indexed page number (positional pagination; exclusive with `cursor`). */
        page?: number | undefined;
        order: 'asc' | 'desc';
    };
}
export {};
//# sourceMappingURL=blocks.d.ts.map