@secondlayer/sdk 10.4.3 → 10.6.0

package/dist/index.d.ts

@@ -1,241 +1,3 @@
-import { ReindexResponse, SubgraphAggregateParams, SubgraphAggregateResponse, SubgraphDetail, SubgraphGapsResponse, SubgraphQueryParams, SubgraphSummary } from "@secondlayer/shared/schemas";
-import { DeploySubgraphRequest, DeploySubgraphResponse } from "@secondlayer/shared/schemas/subgraphs";
-import { SubgraphAgentSchema, SubgraphSpecOptions } from "@secondlayer/shared/subgraphs/spec";
-import { InferSubgraphClient } from "@secondlayer/subgraphs";
-type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-interface SecondLayerOptions {
-	/** Base URL of the instance API (trailing slashes are stripped). */
-	baseUrl: string;
-	/** Bearer token for authenticated instance requests (`INSTANCE_TOKEN`). */
-	apiKey?: string;
-	/** Hosted account key (`sk-sl_*`). Env `SECONDLAYER_API_KEY`. Used by
-	*  `sl.archive` quote/fetch/credits, never by instance `/v1` or `/api`. */
-	accountKey?: string;
-	/** Fetch implementation. Tests and edge runtimes can provide their own. */
-	fetchImpl?: FetchLike;
-	/** Public base URL for Streams bulk parquet dumps (the cold backfill plane).
-	*  Required for `streams.dumps.*`; without it the dumps client falls back to
-	*  its built-in default. */
-	dumpsBaseUrl?: string;
-	/** Public base URL for the signed canonical archive tree. Defaults to
-	*  `https://archive.secondlayer.tools`. Reaches `sl.archive`. */
-	archiveBaseUrl?: string;
-	/** Credits and fetch-gate API. Defaults to `https://api.secondlayer.tools`,
-	*  not `baseUrl`. Reaches `sl.archive` quote/fetch/credits. */
-	archiveOpsUrl?: string;
-	/** Deploy origin label sent as `x-sl-origin` (telemetry). Defaults to `cli`. */
-	origin?: "cli" | "mcp" | "session";
-	/** Check the ed25519 signature on every Streams read. Omit for lenient
-	*  (verify when signed, pass through unsigned self-host responses), `true`
-	*  or `{ publicKey }` for strict, `false` for off. Reaches `sl.streams`. */
-	verify?: boolean | {
-		publicKey: string;
-	};
-	/** Check the dumps manifest signature before trusting any file hash
-	*  (default on). Reaches `sl.streams.dumps`. */
-	verifyDumpsManifest?: boolean;
-	/** How long one request may take, headers and body, before it fails with a
-	*  retryable `ApiError` (default 30 000 ms). A hung socket then trips the
-	*  retry policy instead of stalling a walk or consume loop forever. `0`
-	*  disables the timeout. */
-	requestTimeoutMs?: number;
-}
-/** Default per-request budget. Long enough for a 1000-row filtered page on a
-*  cold cache, short enough that a half-open connection surfaces as a retry. */
-declare const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
-/** Per-call options every `request*` method accepts. */
-type RequestOptions = {
-	/** Cancels the in-flight request (and its body read). The rejection is the
-	*  signal's reason, an `AbortError` by default, never an `ApiError`. */
-	signal?: AbortSignal;
-};
-/** Product default: the local one-box API. Override with `baseUrl` or
-*  `SECONDLAYER_API_URL`. */
-declare const LOCAL_API_URL = "http://127.0.0.1:3800";
-/** Instance credential. `secondlayer init` writes this. */
-declare const INSTANCE_TOKEN_ENV = "INSTANCE_TOKEN";
-/** Hosted account key (`sk-sl_*`) for api.secondlayer.tools. */
-declare const ACCOUNT_KEY_ENV = "SECONDLAYER_API_KEY";
-declare function resolveBaseUrl(explicit?: string): string;
-/** Resolve the instance credential. Precedence: explicit `apiKey` (including
-*  `""` for keyless) → `INSTANCE_TOKEN`. Does not read the hosted account key
-*  env vars. Guarded for browsers and edge runtimes. */
-declare function resolveApiKey(apiKey?: string): string | undefined;
-/** Resolve the hosted account key for archive quote/fetch/credits.
-*  Precedence: explicit `accountKey` → `SECONDLAYER_API_KEY` → `SL_API_KEY` /
-*  `SL_ARCHIVE_API_KEY` (one-release warn-fallbacks). Does not read
-*  `INSTANCE_TOKEN`. */
-declare function resolveAccountKey(accountKey?: string): string | undefined;
-declare abstract class BaseClient {
-	protected baseUrl: string;
-	protected apiKey?: string;
-	protected origin: "cli" | "mcp" | "session";
-	protected fetchImpl: FetchLike;
-	protected requestTimeoutMs: number;
-	constructor(options?: Partial<SecondLayerOptions>);
-	static authHeaders(apiKey?: string): Record<string, string>;
-	protected request<T>(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
-	/** Like `request`, but maps a 404 to `null` instead of throwing — the one
-	*  place that owns the "absent resource" rule for `get*` accessors. */
-	protected requestOrNull<T>(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<T | null>;
-	protected requestText(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<string>;
-	/** Run one request under the caller's signal plus the per-request timeout.
-	*  One combined signal covers the fetch and the body read, so a socket that
-	*  stalls mid-body times out the same way one that never answers does. A
-	*  timeout rejects with a retryable `ApiError`; a caller abort rejects with
-	*  the signal's reason so loops can tell "stop" from "try again". */
-	private withRequestBudget;
-	/** Issue the HTTP request and map non-2xx statuses onto the error family.
-	*  `signal` is the combined caller-plus-timeout signal from `request*`;
-	*  subclasses that stream a body call this directly and read it themselves. */
-	protected fetchResponse(method: string, path: string, body?: unknown, signal?: AbortSignal): Promise<Response>;
-}
-interface SubgraphSource {
-	name: string;
-	version: string;
-	sourceCode: string | null;
-	readOnly: boolean;
-	reason?: string;
-	updatedAt: string;
-}
-/** Status of a tracked reindex/backfill operation (poll until terminal). */
-interface SubgraphOperationStatus {
-	id: string;
-	subgraphName: string;
-	kind: "reindex" | "backfill";
-	status: "queued" | "running" | "completed" | "failed" | "cancelled";
-	fromBlock: number | null;
-	toBlock: number | null;
-	processedBlocks: number | null;
-	/** 0–1 fraction; null when no denominator is known yet. 1 when completed. */
-	progress: number | null;
-	error: string | null;
-	startedAt: string | null;
-	finishedAt: string | null;
-	createdAt: string;
-	updatedAt: string;
-}
-/** /v1 cursor envelope for subgraph table reads. */
-interface SubgraphRowsEnvelope<T = unknown> {
-	rows: T[];
-	next_cursor: string | null;
-	tip: {
-		block_height: number;
-		subgraph_height: number;
-		blocks_behind: number;
-	};
-}
-interface BundleSubgraphResponse {
-	ok: true;
-	name: string;
-	version: string | null;
-	description: string | null;
-	sources: Record<string, Record<string, unknown>>;
-	schema: Record<string, unknown>;
-	handlerCode: string;
-	sourceCode: string;
-	bundleSize: number;
-}
-declare class Subgraphs extends BaseClient {
-	list(): Promise<{
-		data: SubgraphSummary[];
-	}>;
-	/**
-	* The subgraph's current state — health, sync position, tables. The verify
-	* step after a deploy, reindex, or backfill: poll it until `sync` catches
-	* the tip.
-	*/
-	status(name: string): Promise<SubgraphDetail>;
-	openapi(name: string, options?: SubgraphSpecOptions): Promise<Record<string, unknown>>;
-	schema(name: string, options?: SubgraphSpecOptions): Promise<SubgraphAgentSchema>;
-	markdown(name: string, options?: SubgraphSpecOptions): Promise<string>;
-	/**
-	* Reindex always drops and rebuilds the whole subgraph, so it takes no
-	* block range; the API rejects one with `REINDEX_RANGE_NOT_SUPPORTED`.
-	* Use {@link backfill} to process a specific range. While a reindex or
-	* backfill is already running the API answers 409 with code
-	* `OPERATION_IN_PROGRESS`; poll {@link operations} until it finishes.
-	*/
-	reindex(name: string): Promise<ReindexResponse>;
-	stop(name: string): Promise<{
-		message: string;
-		operationId?: string;
-		status?: string;
-	}>;
-	/** Process one block range. 409 `OPERATION_IN_PROGRESS` while another
-	*  reindex or backfill runs on this subgraph. */
-	backfill(name: string, options: {
-		fromBlock: number;
-		toBlock: number;
-	}): Promise<ReindexResponse>;
-	gaps(name: string, opts?: {
-		limit?: number;
-		offset?: number;
-		resolved?: boolean;
-	}): Promise<SubgraphGapsResponse>;
-	delete(name: string, options?: {
-		force?: boolean;
-	}): Promise<{
-		message: string;
-	}>;
-	/**
-	* Open /v1 read: cursor-paginated rows. Anon works on an open instance;
-	* pass an apiKey on the client where reads are closed. Resume with the
-	* returned `next_cursor`.
-	*/
-	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
-		cursor?: string;
-	}): Promise<SubgraphRowsEnvelope<T>>;
-	/** Recent reindex/backfill operations for a subgraph, newest first. */
-	operations(name: string): Promise<{
-		operations: SubgraphOperationStatus[];
-	}>;
-	/** Status of a single operation (poll the `operationId` returned by
-	*  reindex/backfill/stop until `status` is terminal). */
-	getOperation(name: string, operationId: string): Promise<SubgraphOperationStatus>;
-	/** Create or update a subgraph. A deploy that needs a rebuild queues one;
-	*  if a reindex or backfill is already running the API answers 409 with
-	*  code `OPERATION_IN_PROGRESS` (an `ApiError`, not a dedicated class). */
-	deploy(data: DeploySubgraphRequest): Promise<DeploySubgraphResponse>;
-	getSource(name: string): Promise<SubgraphSource>;
-	/**
-	* Bundle a TypeScript subgraph source on the server. Used by the web chat
-	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
-	*/
-	bundle(data: {
-		code: string;
-	}): Promise<BundleSubgraphResponse>;
-	queryTable(name: string, table: string, params?: SubgraphQueryParams): Promise<unknown[]>;
-	queryTableCount(name: string, table: string, params?: SubgraphQueryParams): Promise<{
-		count: number;
-	}>;
-	queryTableAggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
-	/**
-	* Returns a typed client for a subgraph defined with `defineSubgraph()`.
-	* Row types are inferred from the subgraph's schema literal types.
-	*
-	* @example
-	* ```ts
-	* import mySubgraph from './subgraphs/my-token-subgraph'
-	* const client = sl.subgraphs.typed(mySubgraph)
-	* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
-	* // rows: InferTableRow<typeof mySubgraph.schema.transfers>[]
-	* ```
-	*/
-	typed<T extends {
-		name: string;
-		schema: Record<string, unknown>;
-	}>(def: T): InferSubgraphClient<T>;
-	/**
-	* `columns` is the table's declared column set from `defineSubgraph()`.
-	* Filters and orderBy always accept the canonical system names
-	* `_id` / `_blockHeight` / `_txId` / `_createdAt`; the unprefixed
-	* shorthands (`id`, `blockHeight`, ...) mean the system column only when
-	* the table declares no column of that name.
-	*/
-	private createTableClient;
-}
-import { InferSubgraphClient as InferSubgraphClient2 } from "@secondlayer/subgraphs";
 import { InstanceDiagnosis as InstanceDiagnosis2 } from "@secondlayer/shared/archive/instance-diagnosis";
 import { SubgraphSummary as SubgraphSummary2 } from "@secondlayer/shared/schemas";
 import { InstanceDiagnosis, PublicStatus } from "@secondlayer/shared/archive/instance-diagnosis";
@@ -387,6 +149,120 @@ type ArchiveClient = {
 type SecondLayerArchive = ArchiveClient & {
 	verify(input: ArchiveVerifyInput): Promise<ArchiveVerifyResult>;
 };
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface SecondLayerOptions {
+	/** Base URL of the instance API (trailing slashes are stripped). */
+	baseUrl: string;
+	/** Bearer token for authenticated instance requests (`INSTANCE_TOKEN`). */
+	apiKey?: string;
+	/** Hosted account key (`sk-sl_*`). Env `SECONDLAYER_API_KEY`. Used by
+	*  `sl.archive` quote/fetch/credits, never by instance `/v1` or `/api`. */
+	accountKey?: string;
+	/** Fetch implementation. Tests and edge runtimes can provide their own. */
+	fetchImpl?: FetchLike;
+	/** Public base URL for Streams bulk parquet dumps (the cold backfill plane).
+	*  Required for `streams.dumps.*`; without it the dumps client falls back to
+	*  its built-in default. */
+	dumpsBaseUrl?: string;
+	/** Public base URL for the signed canonical archive tree. Defaults to
+	*  `https://archive.secondlayer.tools`. Reaches `sl.archive`. */
+	archiveBaseUrl?: string;
+	/** Credits and fetch-gate API. Defaults to `https://api.secondlayer.tools`,
+	*  not `baseUrl`. Reaches `sl.archive` quote/fetch/credits. */
+	archiveOpsUrl?: string;
+	/** Deploy origin label sent as `x-sl-origin` (telemetry). Defaults to `cli`. */
+	origin?: "cli" | "mcp" | "session";
+	/** Check the ed25519 signature on every Streams read. Omit for lenient
+	*  (verify when signed, pass through unsigned self-host responses), `true`
+	*  or `{ publicKey }` for strict, `false` for off. Reaches `sl.streams`. */
+	verify?: boolean | {
+		publicKey: string;
+	};
+	/** Check the dumps manifest signature before trusting any file hash
+	*  (default on). Reaches `sl.streams.dumps`. */
+	verifyDumpsManifest?: boolean;
+	/** How long one request may take, headers and body, before it fails with a
+	*  retryable `ApiError` (default 30 000 ms). A hung socket then trips the
+	*  retry policy instead of stalling a walk or consume loop forever. `0`
+	*  disables the timeout. */
+	requestTimeoutMs?: number;
+	/** Where GET responses carrying an `ETag` are kept, so a repeat read sends
+	*  `If-None-Match` and a finalized page comes back as a free `304`.
+	*  Defaults to an in-memory store of the last 64 pages. Pass your own to
+	*  keep it across processes (a file, a KV), or `false` to turn it off. */
+	etagCache?: EtagCache | false;
+}
+/** One cached GET response: its validator and the body it validated. */
+type EtagEntry = {
+	etag: string;
+	body: string;
+};
+/** Storage for `etagCache`. Keys are full request URLs. Either method may be
+*  async, so a disk or KV store works as well as a Map. */
+interface EtagCache {
+	get(key: string): EtagEntry | undefined | Promise<EtagEntry | undefined>;
+	set(key: string, entry: EtagEntry): void | Promise<void>;
+}
+/** Bounded in-memory `EtagCache`. Evicts the least recently used page, so a
+*  long walk can't hold more than `limit` page bodies. */
+declare class MemoryEtagCache implements EtagCache {
+	private readonly limit;
+	private entries;
+	constructor(limit?: number);
+	get(key: string): EtagEntry | undefined;
+	set(key: string, entry: EtagEntry): void;
+}
+/** Default per-request budget. Long enough for a 1000-row filtered page on a
+*  cold cache, short enough that a half-open connection surfaces as a retry. */
+declare const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+/** Per-call options every `request*` method accepts. */
+type RequestOptions = {
+	/** Cancels the in-flight request (and its body read). The rejection is the
+	*  signal's reason, an `AbortError` by default, never an `ApiError`. */
+	signal?: AbortSignal;
+};
+/** Product default: the local one-box API. Override with `baseUrl` or
+*  `SECONDLAYER_API_URL`. */
+declare const LOCAL_API_URL = "http://127.0.0.1:3800";
+/** Instance credential. `secondlayer init` writes this. */
+declare const INSTANCE_TOKEN_ENV = "INSTANCE_TOKEN";
+/** Hosted account key (`sk-sl_*`) for api.secondlayer.tools. */
+declare const ACCOUNT_KEY_ENV = "SECONDLAYER_API_KEY";
+declare function resolveBaseUrl(explicit?: string): string;
+/** Resolve the instance credential. Precedence: explicit `apiKey` (including
+*  `""` for keyless) → `INSTANCE_TOKEN`. Does not read the hosted account key
+*  env vars. Guarded for browsers and edge runtimes. */
+declare function resolveApiKey(apiKey?: string): string | undefined;
+/** Resolve the hosted account key for archive quote/fetch/credits.
+*  Precedence: explicit `accountKey` → `SECONDLAYER_API_KEY` → `SL_API_KEY` /
+*  `SL_ARCHIVE_API_KEY` (one-release warn-fallbacks). Does not read
+*  `INSTANCE_TOKEN`. */
+declare function resolveAccountKey(accountKey?: string): string | undefined;
+declare abstract class BaseClient {
+	protected baseUrl: string;
+	protected apiKey?: string;
+	protected origin: "cli" | "mcp" | "session";
+	protected fetchImpl: FetchLike;
+	protected requestTimeoutMs: number;
+	protected etagCache: EtagCache | null;
+	constructor(options?: Partial<SecondLayerOptions>);
+	static authHeaders(apiKey?: string): Record<string, string>;
+	protected request<T>(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+	/** Like `request`, but maps a 404 to `null` instead of throwing — the one
+	*  place that owns the "absent resource" rule for `get*` accessors. */
+	protected requestOrNull<T>(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<T | null>;
+	protected requestText(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<string>;
+	/** Run one request under the caller's signal plus the per-request timeout.
+	*  One combined signal covers the fetch and the body read, so a socket that
+	*  stalls mid-body times out the same way one that never answers does. A
+	*  timeout rejects with a retryable `ApiError`; a caller abort rejects with
+	*  the signal's reason so loops can tell "stop" from "try again". */
+	private withRequestBudget;
+	/** Issue the HTTP request and map non-2xx statuses onto the error family.
+	*  `signal` is the combined caller-plus-timeout signal from `request*`;
+	*  subclasses that stream a body call this directly and read it themselves. */
+	protected fetchResponse(method: string, path: string, body?: unknown, signal?: AbortSignal, extraHeaders?: Record<string, string>): Promise<Response>;
+}
 /**
 * Typed client for the contract-discovery API (`GET /v1/contracts`).
 *
@@ -2617,6 +2493,154 @@ declare class Index extends BaseClient {
 	private walkPoxCycles;
 	private getPoxCycle;
 }
+import { ReindexResponse, SubgraphAggregateParams, SubgraphAggregateResponse, SubgraphDetail, SubgraphGapsResponse, SubgraphQueryParams, SubgraphSummary } from "@secondlayer/shared/schemas";
+import { DeploySubgraphRequest, DeploySubgraphResponse } from "@secondlayer/shared/schemas/subgraphs";
+import { SubgraphAgentSchema, SubgraphSpecOptions } from "@secondlayer/shared/subgraphs/spec";
+import { InferSubgraphClient } from "@secondlayer/subgraphs";
+interface SubgraphSource {
+	name: string;
+	version: string;
+	sourceCode: string | null;
+	readOnly: boolean;
+	reason?: string;
+	updatedAt: string;
+}
+/** Status of a tracked reindex/backfill operation (poll until terminal). */
+interface SubgraphOperationStatus {
+	id: string;
+	subgraphName: string;
+	kind: "reindex" | "backfill";
+	status: "queued" | "running" | "completed" | "failed" | "cancelled";
+	fromBlock: number | null;
+	toBlock: number | null;
+	processedBlocks: number | null;
+	/** 0–1 fraction; null when no denominator is known yet. 1 when completed. */
+	progress: number | null;
+	error: string | null;
+	startedAt: string | null;
+	finishedAt: string | null;
+	createdAt: string;
+	updatedAt: string;
+}
+/** /v1 cursor envelope for subgraph table reads. */
+interface SubgraphRowsEnvelope<T = unknown> {
+	rows: T[];
+	next_cursor: string | null;
+	tip: {
+		block_height: number;
+		subgraph_height: number;
+		blocks_behind: number;
+	};
+}
+interface BundleSubgraphResponse {
+	ok: true;
+	name: string;
+	description: string | null;
+	sources: Record<string, Record<string, unknown>>;
+	schema: Record<string, unknown>;
+	handlerCode: string;
+	sourceCode: string;
+	bundleSize: number;
+}
+declare class Subgraphs extends BaseClient {
+	list(): Promise<{
+		data: SubgraphSummary[];
+	}>;
+	/**
+	* The subgraph's current state — health, sync position, tables. The verify
+	* step after a deploy, reindex, or backfill: poll it until `sync` catches
+	* the tip.
+	*/
+	status(name: string): Promise<SubgraphDetail>;
+	openapi(name: string, options?: SubgraphSpecOptions): Promise<Record<string, unknown>>;
+	schema(name: string, options?: SubgraphSpecOptions): Promise<SubgraphAgentSchema>;
+	markdown(name: string, options?: SubgraphSpecOptions): Promise<string>;
+	/**
+	* Reindex always drops and rebuilds the whole subgraph, so it takes no
+	* block range; the API rejects one with `REINDEX_RANGE_NOT_SUPPORTED`.
+	* Use {@link backfill} to process a specific range. While a reindex or
+	* backfill is already running the API answers 409 with code
+	* `OPERATION_IN_PROGRESS`; poll {@link operations} until it finishes.
+	*/
+	reindex(name: string): Promise<ReindexResponse>;
+	stop(name: string): Promise<{
+		message: string;
+		operationId?: string;
+		status?: string;
+	}>;
+	/** Process one block range. 409 `OPERATION_IN_PROGRESS` while another
+	*  reindex or backfill runs on this subgraph. */
+	backfill(name: string, options: {
+		fromBlock: number;
+		toBlock: number;
+	}): Promise<ReindexResponse>;
+	gaps(name: string, opts?: {
+		limit?: number;
+		offset?: number;
+		resolved?: boolean;
+	}): Promise<SubgraphGapsResponse>;
+	delete(name: string, options?: {
+		force?: boolean;
+	}): Promise<{
+		message: string;
+	}>;
+	/**
+	* Open /v1 read: cursor-paginated rows. Anon works on an open instance;
+	* pass an apiKey on the client where reads are closed. Resume with the
+	* returned `next_cursor`.
+	*/
+	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
+		cursor?: string;
+	}): Promise<SubgraphRowsEnvelope<T>>;
+	/** Recent reindex/backfill operations for a subgraph, newest first. */
+	operations(name: string): Promise<{
+		operations: SubgraphOperationStatus[];
+	}>;
+	/** Status of a single operation (poll the `operationId` returned by
+	*  reindex/backfill/stop until `status` is terminal). */
+	getOperation(name: string, operationId: string): Promise<SubgraphOperationStatus>;
+	/** Create or update a subgraph. A deploy that needs a rebuild queues one;
+	*  if a reindex or backfill is already running the API answers 409 with
+	*  code `OPERATION_IN_PROGRESS` (an `ApiError`, not a dedicated class). */
+	deploy(data: DeploySubgraphRequest): Promise<DeploySubgraphResponse>;
+	getSource(name: string): Promise<SubgraphSource>;
+	/**
+	* Bundle a TypeScript subgraph source on the server. Used by the web chat
+	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
+	*/
+	bundle(data: {
+		code: string;
+	}): Promise<BundleSubgraphResponse>;
+	queryTable(name: string, table: string, params?: SubgraphQueryParams): Promise<unknown[]>;
+	queryTableCount(name: string, table: string, params?: SubgraphQueryParams): Promise<{
+		count: number;
+	}>;
+	queryTableAggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
+	/**
+	* Returns a typed client for a subgraph defined with `defineSubgraph()`.
+	* Row types are inferred from the subgraph's schema literal types.
+	*
+	* @example
+	* ```ts
+	* import mySubgraph from './subgraphs/my-token-subgraph'
+	* const client = sl.subgraphs.typed(mySubgraph)
+	* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
+	* // rows: InferTableRow<typeof mySubgraph.schema.transfers>[]
+	* ```
+	*/
+	typed<T extends {
+		name: string;
+		schema: Record<string, unknown>;
+	}>(def: T): InferSubgraphClient<T>;
+	/**
+	* `columns` is the table's declared column set from `defineSubgraph()`.
+	* Filters and orderBy always accept the canonical system names
+	* `_id` / `_blockHeight` / `_txId` / `_createdAt`; the unprefixed
+	* shorthands (`id`, `blockHeight`, ...) mean the system column only when
+	* the table declares no column of that name.
+	*/
+	private createTableClient;
+}
 import { CreateWebhookRequest, CreateWebhookResponse, DeadRow, DeliveryRow, ReplayResult, RotateSecretResponse, UpdateWebhookRequest, WebhookDetail, WebhookSummary, WebhookTestResult } from "@secondlayer/shared/schemas/webhooks";
 import { ChainTrigger, ChainTriggerType, CreateWebhookRequest as CreateWebhookRequest2, CreateWebhookResponse as CreateWebhookResponse2, DeadRow as DeadRow2, DeliveryRow as DeliveryRow2, ReplayResult as ReplayResult2, RotateSecretResponse as RotateSecretResponse2, WebhookDetail as WebhookDetail2, WebhookFormat, WebhookKind, WebhookRuntime, WebhookStatus, WebhookSummary as WebhookSummary2, WebhookTestResult as WebhookTestResult2, UpdateWebhookRequest as UpdateWebhookRequest2 } from "@secondlayer/shared/schemas/webhooks";
 import { trigger } from "@secondlayer/shared/schemas/webhooks";
@@ -2740,81 +2764,68 @@ declare class SecondLayer extends BaseClient {
 	*/
 	context(): Promise<ContextSnapshot>;
 }
+import { InstanceDiagnosis as InstanceDiagnosis3, InstanceIssue, InstanceState, PublicStatus as PublicStatus2 } from "@secondlayer/shared/archive/instance-diagnosis";
+import { InferSubgraphClient as InferSubgraphClient2 } from "@secondlayer/subgraphs";
 /**
 * Returns a typed client for a subgraph defined with `defineSubgraph()`.
 *
-* Accepts a plain options object, a `SecondLayer` instance, or a `Subgraphs` instance.
-*
-* @example
-* ```ts
-* import mySubgraph from './subgraphs/my-subgraph'
-* import { getSubgraph } from '@secondlayer/sdk'
-*
-* const client = getSubgraph(mySubgraph, { apiKey: 'sl_...' })
-* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
-* ```
-*/
-declare function getSubgraph<T extends {
-	name: string;
-	schema: Record<string, unknown>;
-}>(def: T, options?: Partial<SecondLayerOptions> | SecondLayer | Subgraphs): InferSubgraphClient2<T>;
-type CreateStreamsClientOptions = {
-	apiKey?: string;
-	baseUrl?: string;
-	/** Deploy origin label sent as `x-sl-origin` (telemetry). Defaults to `cli`. */
-	origin?: "cli" | "mcp" | "session";
-	fetchImpl?: FetchLike2;
-	/**
-	* Public base URL for bulk parquet dumps (the R2/CDN bucket root). Required
-	* to use `client.dumps`. See `GET /public/streams/dumps/manifest`.
-	*/
-	dumpsBaseUrl?: string;
-	/**
-	* Verify the ed25519 `X-Signature` on every REST response and per-frame SSE
-	* signature. Three states:
-	* - **default (omitted)** — *lenient*: verify when the server signs (the
-	*   hosted API signs every response), and pass through when no signature is
-	*   present (e.g. a self-hosted instance with no `STREAMS_SIGNING_PRIVATE_KEY`).
-	*   So verification is on by default against the hosted API without breaking
-	*   unsigned self-host deployments. An *invalid* signature always throws.
-	* - **`true`** (or `{ publicKey }` to pin a known PEM) — *strict*: a missing
-	*   OR invalid signature throws `StreamsSignatureError`. Use this when you
-	*   require a portable, non-repudiable attestation and won't accept unsigned
-	*   data (it also closes the lenient mode's strip-the-header downgrade).
-	* - **`false`** — off.
-	*
-	* The key is fetched once from `/public/streams/signing-key` (cached; a
-	* rotated `X-Signature-KeyId` triggers one refresh) unless a PEM is pinned.
-	*/
-	verify?: boolean | {
-		publicKey: string;
-	};
-	/**
-	* Verify the bulk dumps manifest's ed25519 signature in `client.dumps.list()`
-	* before trusting any file sha256 (default ON). Uses the same key source as
-	* `verify` (fetches `/public/streams/signing-key`, or a pinned PEM). Pass
-	* `false` to opt out. A missing or invalid signature throws
-	* `StreamsSignatureError`.
-	*/
-	verifyDumpsManifest?: boolean;
-};
-declare function createStreamsClient(options: CreateStreamsClientOptions): StreamsClient;
-/**
-* Decode a raw Streams event into the SAME flat, `event_type`-discriminated
-* row shape Index serves — so Streams consumption reads identically to Index
-* consumption, with one call instead of eleven guard+decode pairs.
-*
+* Accepts a plain options object, a `SecondLayer` instance, or a `Subgraphs` instance.
+*
+* @example
 * ```ts
-* for (const event of envelope.events) {
-*   const row = decode(event);
-*   if (row.event_type === "ft_transfer") row.amount; // string, narrowed
-* }
+* import mySubgraph from './subgraphs/my-subgraph'
+* import { getSubgraph } from '@secondlayer/sdk'
+*
+* const client = getSubgraph(mySubgraph, { apiKey: 'sl_...' })
+* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
 * ```
+*/
+declare function getSubgraph<T extends {
+	name: string;
+	schema: Record<string, unknown>;
+}>(def: T, options?: Partial<SecondLayerOptions> | SecondLayer | Subgraphs): InferSubgraphClient2<T>;
+import { SubgraphAgentSchema as SubgraphAgentSchema3, SubgraphSpecFormat as SubgraphSpecFormat2, SubgraphSpecOptions as SubgraphSpecOptions3 } from "@secondlayer/shared/subgraphs/spec";
+/**
+* The two pieces every "deploy a consumer" guide leaves out, packaged:
+* a liveness endpoint and a graceful-shutdown signal. Both are
+* runtime-agnostic — the SDK never binds a port or assumes Bun/Node.
+*/
+interface ConsumerHealth {
+	/** Feed this to the consume loop's `onProgress` — it stamps arrival time
+	*  and keeps the latest progress ctx for the health body. */
+	record: (ctx: ConsumerBatchContext) => void;
+	/** Fetch-style handler for `GET /health`. Mount it on whatever serves
+	*  HTTP in your runtime:
+	*  `Bun.serve({ port, fetch: health.handler })` ·
+	*  `http.createServer(...)` via an adapter · a Workers route. */
+	handler: (req: Request) => Response;
+}
+/**
+* Liveness for a consume loop. The gate is "did a page land recently", NOT
+* "are we near the tip": during a genesis backfill the loop is millions of
+* blocks behind and perfectly healthy, so lag can't be the signal. A wedged
+* loop stops reporting pages and flips to 503 — that's what platforms
+* should restart on. The body carries position for dashboards:
+* `blocks_behind` is the actual backlog (`tip - scanned_height`, ~0 for a
+* caught-up tail even on a quiet contract), while `last_delivered_height`
+* is the last DELIVERED row — its distance from the tip is event age, not
+* lag.
+*/
+declare function consumerHealth(options?: {
+	staleAfterMs?: number;
+}): ConsumerHealth;
+/**
+* An `AbortSignal` wired to SIGTERM/SIGINT (redeploys arrive as SIGTERM).
+* Pass it as the consume loop's `signal`: aborting is checked at the top of
+* the loop, never mid-batch, so the in-flight transaction — rows AND
+* checkpoint — always commits before the process exits. Nothing is
+* half-written; the next run resumes from exactly that cursor.
 *
-* Prefer `decoded: true` on `streams.events.consume` — then decoding never
-* appears in your code at all.
+* No-op (never fires) on runtimes without `process` signal handling.
 */
-declare function decode(event: StreamsEvent): IndexEvent;
+declare function shutdownSignal(options?: {
+	signals?: readonly ("SIGTERM" | "SIGINT")[];
+}): AbortSignal;
 /** Options accepted by every error in the family. */
 interface SecondLayerErrorOptions {
 	cause?: Error;
@@ -2929,97 +2940,6 @@ declare class ArchiveGateNotConfiguredError extends SecondLayerError {
 }
 /** Parse a `Retry-After` header: delta-seconds or an HTTP-date. */
 declare function parseRetryAfter(value?: string | null): number | undefined;
-/** Thrown on a 5xx from the Streams API, and on a failed signing-key fetch.
-*  `retryable`: the page retry policy tries again. */
-declare class StreamsServerError extends ApiError {
-	constructor(message: string, status: number, body?: unknown, code?: string);
-}
-/** Thrown when response signature verification is enabled and fails. */
-declare class StreamsSignatureError extends SecondLayerError {
-	constructor(message?: string);
-}
-import { decodeFtTransfer, isFtTransfer, decodeNftTransfer, isNftTransfer, decodeStxBurn, decodeStxLock, decodeStxMint, decodeStxTransfer, isStxBurn, isStxLock, isStxMint, isStxTransfer, decodeFtBurn, decodeFtMint, decodeNftBurn, decodeNftMint, isFtBurn, isFtMint, isNftBurn, isNftMint, decodePrint, isPrint } from "@secondlayer/shared/streams-rows";
-import { DecodedEventColumns, DecodedEventRow, DecodedFtBurn, DecodedFtBurnPayload, DecodedFtMint, DecodedFtMintPayload, DecodedFtTransfer, DecodedFtTransferPayload, DecodedNftBurn, DecodedNftBurnPayload, DecodedNftMint, DecodedNftMintPayload, DecodedNftTransfer, DecodedNftTransferPayload, DecodedPrint, DecodedPrintPayload, DecodedPrintValue, DecodedStxBurn, DecodedStxBurnPayload, DecodedStxLock, DecodedStxLockPayload, DecodedStxMint, DecodedStxMintPayload, DecodedStxTransfer, DecodedStxTransferPayload, FtTransferEvent, FtTransferPayload as FtTransferPayload2, NftTransferEvent, NftTransferPayload as NftTransferPayload2 } from "@secondlayer/shared/streams-rows";
-/**
-* Helpers for Streams cursors. A cursor is the opaque `<block>:<index>` string
-* that marks a position in the event stream; treat the format as an
-* implementation detail and go through these helpers instead of string-building
-* it at call sites. Encode/decode and the rewind sentinel come from the
-* canonical codec in `@secondlayer/shared` so the SDK cannot accept a spelling
-* the server would 400, or rewind to a different foot than Index/Streams.
-*/
-declare const Cursor: {
-	/**
-	* Cursor at the foot of `height` — a position that sorts strictly below the
-	* first event of block `height` (`height:0`) and strictly above every event
-	* of block `height - 1`. Cursors are exclusive (`(bh,ei) > after`), so
-	* resuming from it re-reads the entire canonical run starting at `height:0`
-	* inclusive. This is the position to rewind to after a reorg whose fork point
-	* is `height`: the new canonical block at `height` carries a fresh first
-	* event at `(height, 0)` that the consumer MUST re-read.
-	*
-	* Encoded as `blockEndCursor(height - 1)` rather than the seemingly-natural
-	* `${height}:0` — that earlier form was an off-by-one: being exclusive, it
-	* skipped `(height, 0)`, silently dropping the fork block's first row on
-	* every reorg. The sentinel is int4 max (the `event_index`/`tx_index` column
-	* type), larger than any real index, so nothing at `height - 1` survives the
-	* keyset and the next returned row is exactly `(height, 0)`.
-	*
-	* `atHeight(0)` is `null`: the pre-genesis position both consume loops
-	* accept as "read everything from the first event". There is no string
-	* cursor below `0:0`, and `0:0` itself is exclusive, so returning it here
-	* skipped the genesis event.
-	*/
-	atHeight(height: number): string | null;
-	/** Parse a `<block>:<index>` cursor. Throws `ValidationError` if malformed. */
-	parse(cursor: string): {
-		blockHeight: number;
-		eventIndex: number;
-	};
-};
-import { InstanceDiagnosis as InstanceDiagnosis3, InstanceIssue, InstanceState, PublicStatus as PublicStatus2 } from "@secondlayer/shared/archive/instance-diagnosis";
-import { SubgraphAgentSchema as SubgraphAgentSchema3, SubgraphSpecFormat as SubgraphSpecFormat2, SubgraphSpecOptions as SubgraphSpecOptions3 } from "@secondlayer/shared/subgraphs/spec";
-/**
-* The two pieces every "deploy a consumer" guide leaves out, packaged:
-* a liveness endpoint and a graceful-shutdown signal. Both are
-* runtime-agnostic — the SDK never binds a port or assumes Bun/Node.
-*/
-interface ConsumerHealth {
-	/** Feed this to the consume loop's `onProgress` — it stamps arrival time
-	*  and keeps the latest progress ctx for the health body. */
-	record: (ctx: ConsumerBatchContext) => void;
-	/** Fetch-style handler for `GET /health`. Mount it on whatever serves
-	*  HTTP in your runtime:
-	*  `Bun.serve({ port, fetch: health.handler })` ·
-	*  `http.createServer(...)` via an adapter · a Workers route. */
-	handler: (req: Request) => Response;
-}
-/**
-* Liveness for a consume loop. The gate is "did a page land recently", NOT
-* "are we near the tip": during a genesis backfill the loop is millions of
-* blocks behind and perfectly healthy, so lag can't be the signal. A wedged
-* loop stops reporting pages and flips to 503 — that's what platforms
-* should restart on. The body carries position for dashboards:
-* `blocks_behind` is the actual backlog (`tip - scanned_height`, ~0 for a
-* caught-up tail even on a quiet contract), while `last_delivered_height`
-* is the last DELIVERED row — its distance from the tip is event age, not
-* lag.
-*/
-declare function consumerHealth(options?: {
-	staleAfterMs?: number;
-}): ConsumerHealth;
-/**
-* An `AbortSignal` wired to SIGTERM/SIGINT (redeploys arrive as SIGTERM).
-* Pass it as the consume loop's `signal`: aborting is checked at the top of
-* the loop, never mid-batch, so the in-flight transaction — rows AND
-* checkpoint — always commits before the process exits. Nothing is
-* half-written; the next run resumes from exactly that cursor.
-*
-* No-op (never fires) on runtimes without `process` signal handling.
-*/
-declare function shutdownSignal(options?: {
-	signals?: readonly ("SIGTERM" | "SIGINT")[];
-}): AbortSignal;
 type CreateArchiveClientOptions = {
 	/** @deprecated Prefer `accountKey`. Kept one release as an alias. */
 	apiKey?: string;
@@ -3188,5 +3108,110 @@ declare function verifySecondlayerSignature(rawBody: string, headers: WebhookHea
 */
 declare function decodeChainWebhook(rawBody: string): ChainWebhookDelivery;
 import { RewardSet as RewardSet2 } from "@secondlayer/shared/node/consensus";
+type CreateStreamsClientOptions = {
+	apiKey?: string;
+	baseUrl?: string;
+	/** Deploy origin label sent as `x-sl-origin` (telemetry). Defaults to `cli`. */
+	origin?: "cli" | "mcp" | "session";
+	fetchImpl?: FetchLike2;
+	/**
+	* Public base URL for bulk parquet dumps (the R2/CDN bucket root). Required
+	* to use `client.dumps`. See `GET /public/streams/dumps/manifest`.
+	*/
+	dumpsBaseUrl?: string;
+	/**
+	* Verify the ed25519 `X-Signature` on every REST response and per-frame SSE
+	* signature. Three states:
+	* - **default (omitted)** — *lenient*: verify when the server signs (the
+	*   hosted API signs every response), and pass through when no signature is
+	*   present (e.g. a self-hosted instance with no `STREAMS_SIGNING_PRIVATE_KEY`).
+	*   So verification is on by default against the hosted API without breaking
+	*   unsigned self-host deployments. An *invalid* signature always throws.
+	* - **`true`** (or `{ publicKey }` to pin a known PEM) — *strict*: a missing
+	*   OR invalid signature throws `StreamsSignatureError`. Use this when you
+	*   require a portable, non-repudiable attestation and won't accept unsigned
+	*   data (it also closes the lenient mode's strip-the-header downgrade).
+	* - **`false`** — off.
+	*
+	* The key is fetched once from `/public/streams/signing-key` (cached; a
+	* rotated `X-Signature-KeyId` triggers one refresh) unless a PEM is pinned.
+	*/
+	verify?: boolean | {
+		publicKey: string;
+	};
+	/**
+	* Verify the bulk dumps manifest's ed25519 signature in `client.dumps.list()`
+	* before trusting any file sha256 (default ON). Uses the same key source as
+	* `verify` (fetches `/public/streams/signing-key`, or a pinned PEM). Pass
+	* `false` to opt out. A missing or invalid signature throws
+	* `StreamsSignatureError`.
+	*/
+	verifyDumpsManifest?: boolean;
+};
+declare function createStreamsClient(options: CreateStreamsClientOptions): StreamsClient;
+/**
+* Decode a raw Streams event into the SAME flat, `event_type`-discriminated
+* row shape Index serves — so Streams consumption reads identically to Index
+* consumption, with one call instead of eleven guard+decode pairs.
+*
+* ```ts
+* for (const event of envelope.events) {
+*   const row = decode(event);
+*   if (row.event_type === "ft_transfer") row.amount; // string, narrowed
+* }
+* ```
+*
+* Prefer `decoded: true` on `streams.events.consume` — then decoding never
+* appears in your code at all.
+*/
+declare function decode(event: StreamsEvent): IndexEvent;
+/** Thrown on a 5xx from the Streams API, and on a failed signing-key fetch.
+*  `retryable`: the page retry policy tries again. */
+declare class StreamsServerError extends ApiError {
+	constructor(message: string, status: number, body?: unknown, code?: string);
+}
+/** Thrown when response signature verification is enabled and fails. */
+declare class StreamsSignatureError extends SecondLayerError {
+	constructor(message?: string);
+}
+import { decodeFtTransfer, isFtTransfer, decodeNftTransfer, isNftTransfer, decodeStxBurn, decodeStxLock, decodeStxMint, decodeStxTransfer, isStxBurn, isStxLock, isStxMint, isStxTransfer, decodeFtBurn, decodeFtMint, decodeNftBurn, decodeNftMint, isFtBurn, isFtMint, isNftBurn, isNftMint, decodePrint, isPrint } from "@secondlayer/shared/streams-rows";
+import { DecodedEventColumns, DecodedEventRow, DecodedFtBurn, DecodedFtBurnPayload, DecodedFtMint, DecodedFtMintPayload, DecodedFtTransfer, DecodedFtTransferPayload, DecodedNftBurn, DecodedNftBurnPayload, DecodedNftMint, DecodedNftMintPayload, DecodedNftTransfer, DecodedNftTransferPayload, DecodedPrint, DecodedPrintPayload, DecodedPrintValue, DecodedStxBurn, DecodedStxBurnPayload, DecodedStxLock, DecodedStxLockPayload, DecodedStxMint, DecodedStxMintPayload, DecodedStxTransfer, DecodedStxTransferPayload, FtTransferEvent, FtTransferPayload as FtTransferPayload2, NftTransferEvent, NftTransferPayload as NftTransferPayload2 } from "@secondlayer/shared/streams-rows";
+/**
+* Helpers for Streams cursors. A cursor is the opaque `<block>:<index>` string
+* that marks a position in the event stream; treat the format as an
+* implementation detail and go through these helpers instead of string-building
+* it at call sites. Encode/decode and the rewind sentinel come from the
+* canonical codec in `@secondlayer/shared` so the SDK cannot accept a spelling
+* the server would 400, or rewind to a different foot than Index/Streams.
+*/
+declare const Cursor: {
+	/**
+	* Cursor at the foot of `height` — a position that sorts strictly below the
+	* first event of block `height` (`height:0`) and strictly above every event
+	* of block `height - 1`. Cursors are exclusive (`(bh,ei) > after`), so
+	* resuming from it re-reads the entire canonical run starting at `height:0`
+	* inclusive. This is the position to rewind to after a reorg whose fork point
+	* is `height`: the new canonical block at `height` carries a fresh first
+	* event at `(height, 0)` that the consumer MUST re-read.
+	*
+	* Encoded as `blockEndCursor(height - 1)` rather than the seemingly-natural
+	* `${height}:0` — that earlier form was an off-by-one: being exclusive, it
+	* skipped `(height, 0)`, silently dropping the fork block's first row on
+	* every reorg. The sentinel is int4 max (the `event_index`/`tx_index` column
+	* type), larger than any real index, so nothing at `height - 1` survives the
+	* keyset and the next returned row is exactly `(height, 0)`.
+	*
+	* `atHeight(0)` is `null`: the pre-genesis position both consume loops
+	* accept as "read everything from the first event". There is no string
+	* cursor below `0:0`, and `0:0` itself is exclusive, so returning it here
+	* skipped the genesis event.
+	*/
+	atHeight(height: number): string | null;
+	/** Parse a `<block>:<index>` cursor. Throws `ValidationError` if malformed. */
+	parse(cursor: string): {
+		blockHeight: number;
+		eventIndex: number;
+	};
+};
 import { decodeClarityValue, toJsonSafe } from "@secondlayer/shared/streams-rows";
-export { verifyWebhookSignature, verifyTransactionProof, verify as verifyStandardWebhooksHeaders, verifySecondlayerSignature, trigger, toJsonSafe, shutdownSignal, resolveBaseUrl, resolveApiKey, resolveAccountKey, parseRetryAfter, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, fetchRewardSet, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, decodeChainWebhook, decode, createStreamsClient, createArchiveClient, contextField, consumerHealth, consumeIndexFeed, WithSinkTx, Webhooks, WebhookTestResult2 as WebhookTestResult, WebhookSummary2 as WebhookSummary, WebhookStatus, WebhookRuntime, WebhookKind, WebhookHeaderInput, WebhookFormat, WebhookDetail2 as WebhookDetail, WalkOptions, VmStreamsEvent, ValidationError, UpdateWebhookRequest2 as UpdateWebhookRequest, TransactionsWalkParams, TransactionsListParams, TransactionsEnvelope, TransactionProofVerifyResult, TransactionProof, TransactionEnvelope, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphOperationStatus, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsWireEvent2 as StreamsWireEvent, StreamsTip, StreamsSubscription, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsSubscribeParams, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsConsumeParams, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StreamsBatch, StandardWebhooksHeaders2 as StandardWebhooksHeaders, StackingWalkParams, StackingListParams, StackingEnvelope, SinkTx, SecondLayerOptions, SecondLayerErrorOptions, SecondLayerError, SecondLayerArchive, SecondLayer, SbtcWithdrawalsWalkParams, SbtcWithdrawalsListParams, SbtcWithdrawalsEnvelope, SbtcWithdrawalSweptConfirmedEvent, SbtcWithdrawalStatus, SbtcWithdrawalEvent, SbtcWithdrawalEnvelope, SbtcSummaryEnvelope, SbtcResource, SbtcEventsWalkParams, SbtcEventsListParams, SbtcEventsEnvelope, SbtcEventsConsumeParams, SbtcEventTopic2 as SbtcEventTopic, SbtcDepositsWalkParams, SbtcDepositsListParams, SbtcDepositsEnvelope, SbtcDepositsConsumeParams, SbtcDepositEvent, SbtcDepositEnvelope, RotateSecretResponse2 as RotateSecretResponse, RewardSet2 as RewardSet, RequestOptions, ReplayResult2 as ReplayResult, RateLimitError, PublicStatus2 as PublicStatus, PrintSchemaResponse, PoxResource, PoxCyclesWalkParams, PoxCyclesListParams, PoxCyclesEnvelope, PoxCycleEnvelope, Pox5Resource, Pox5EventsWalkParams, Pox5EventsListParams, Pox5EventsEnvelope, NftTransfersWalkParams, NftTransfersResource, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload2 as NftTransferPayload, NftTransferEvent, NftTransfer, MempoolWalkParams, MempoolTransactionEnvelope, MempoolListParams, MempoolEnvelope, LoadedArchive, LOCAL_API_URL, InsufficientArchiveCreditsError, InstanceStatus, InstanceState, InstanceIssue, InstanceDiagnosis3 as InstanceDiagnosis, InstanceClient, IndexVarSet, IndexTransaction, IndexTip, IndexStxTransfer, IndexStxMint, IndexStxLock, IndexStxBurn, IndexStackingAction, IndexSbtcWithdrawalPhase, IndexSbtcWithdrawalDetail, IndexSbtcWithdrawal, IndexSbtcSummary, IndexSbtcEvent, IndexSbtcDepositDetail, IndexSbtcDeposit, IndexReorg, IndexPrint, IndexPoxFunctionCount, IndexPoxCycle, IndexPox5EventTopic, IndexPox5Event, IndexPostCondition, IndexNftTransfer, IndexNftMint, IndexNftBurn, IndexNestedContractCall, IndexMempoolTransaction, IndexMapSet, IndexMapInsert, IndexMapDelete, IndexFtTransfer, IndexFtMint, IndexFtBurn, IndexFeedItem, IndexFeedFetcher, IndexFeedEnvelope, IndexEventsResource, IndexEventTypeFilters, IndexEventType, IndexEventOf, IndexEventFields, IndexEvent, IndexDiscovery, IndexContractCall, IndexConsumeOptions, IndexCanonicalBlock, IndexBlock, IndexAlwaysFields, Index, INSTANCE_TOKEN_ENV, INDEX_MAX_PAGE_SIZE, FtTransfersWalkParams, FtTransfersResource, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload2 as FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, EventsConsumeParams, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, DEFAULT_REQUEST_TIMEOUT_MS, Cursor, CreateWebhookResponse2 as CreateWebhookResponse, CreateWebhookRequest2 as CreateWebhookRequest, CreateArchiveClientOptions, ContractsListParams, ContractsEnvelope, Contracts, ContractSummary, ContractConformance, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, ContractCallsConsumeParams, ContextSnapshot, ContextFieldError, ContextField, ContextAccount, ConsumerSink, ConsumerHealth, ConsumerBatchContext, ChainWebhookEnvelope, ChainWebhookDelivery2 as ChainWebhookDelivery, ChainTxLevelEvent, ChainTriggerType, ChainTrigger, ChainTestDelivery, ChainStxTransferData, ChainStxMintData, ChainStxLockData, ChainStxBurnData, ChainReorgRollbackEnvelope, ChainReorgRollbackDelivery, ChainReorgOrphanedEntry, ChainPrintEventData, ChainNftTransferData, ChainNftMintData, ChainNftBurnData, ChainFtTransferData, ChainFtMintData, ChainFtBurnData, ChainEventEnvelope, ChainApplyEnvelopeOf, ChainApplyEnvelope, ChainApplyDeliveryOf, CanonicalWalkParams, CanonicalListParams, CanonicalEnvelope, BlocksWalkParams, BlocksListParams, BlocksEnvelope, BlockEnvelope, AuthError, ArchiveVerifyResult, ArchiveVerifyRangeStatus, ArchiveVerifyInput, ArchiveStatus, ArchiveSignatureError, ArchiveQuote, ArchivePartition, ArchiveManifest, ArchiveLoadOptions, ArchiveGateNotConfiguredError, ArchiveFlow, ArchiveFetchResult, ArchiveFetchItem, ArchiveDataset, ArchiveCreditsBalance, ArchiveClient, ArchiveAuthError, ApiError, ActiveSubgraphOperation, ACCOUNT_KEY_ENV };
+export { ACCOUNT_KEY_ENV, ActiveSubgraphOperation, ApiError, ArchiveAuthError, ArchiveClient, ArchiveCreditsBalance, ArchiveDataset, ArchiveFetchItem, ArchiveFetchResult, ArchiveFlow, ArchiveGateNotConfiguredError, ArchiveLoadOptions, ArchiveManifest, ArchivePartition, ArchiveQuote, ArchiveSignatureError, ArchiveStatus, ArchiveVerifyInput, ArchiveVerifyRangeStatus, ArchiveVerifyResult, AuthError, BlockEnvelope, BlocksEnvelope, BlocksListParams, BlocksWalkParams, CanonicalEnvelope, CanonicalListParams, CanonicalWalkParams, ChainApplyDeliveryOf, ChainApplyEnvelope, ChainApplyEnvelopeOf, ChainEventEnvelope, ChainFtBurnData, ChainFtMintData, ChainFtTransferData, ChainNftBurnData, ChainNftMintData, ChainNftTransferData, ChainPrintEventData, ChainReorgOrphanedEntry, ChainReorgRollbackDelivery, ChainReorgRollbackEnvelope, ChainStxBurnData, ChainStxLockData, ChainStxMintData, ChainStxTransferData, ChainTestDelivery, ChainTrigger, ChainTriggerType, ChainTxLevelEvent, ChainWebhookDelivery2 as ChainWebhookDelivery, ChainWebhookEnvelope, ConsumerBatchContext, ConsumerHealth, ConsumerSink, ContextAccount, ContextField, ContextFieldError, ContextSnapshot, ContractCallsConsumeParams, ContractCallsEnvelope, ContractCallsListParams, ContractCallsWalkParams, ContractConformance, ContractSummary, Contracts, ContractsEnvelope, ContractsListParams, CreateArchiveClientOptions, CreateWebhookRequest2 as CreateWebhookRequest, CreateWebhookResponse2 as CreateWebhookResponse, Cursor, DEFAULT_REQUEST_TIMEOUT_MS, DeadRow2 as DeadRow, DecodedEventColumns, DecodedEventRow, DecodedFtBurn, DecodedFtBurnPayload, DecodedFtMint, DecodedFtMintPayload, DecodedFtTransfer, DecodedFtTransferPayload, DecodedNftBurn, DecodedNftBurnPayload, DecodedNftMint, DecodedNftMintPayload, DecodedNftTransfer, DecodedNftTransferPayload, DecodedPrint, DecodedPrintPayload, DecodedPrintValue, DecodedStxBurn, DecodedStxBurnPayload, DecodedStxLock, DecodedStxLockPayload, DecodedStxMint, DecodedStxMintPayload, DecodedStxTransfer, DecodedStxTransferPayload, DeliveryRow2 as DeliveryRow, EtagCache, EtagEntry, EventsConsumeParams, EventsEnvelope, EventsListParams, EventsWalkParams, FetchLike2 as FetchLike, FtTransfer, FtTransferEvent, FtTransferPayload2 as FtTransferPayload, FtTransfersEnvelope, FtTransfersListParams, FtTransfersResource, FtTransfersWalkParams, INDEX_MAX_PAGE_SIZE, INSTANCE_TOKEN_ENV, Index, IndexAlwaysFields, IndexBlock, IndexCanonicalBlock, IndexConsumeOptions, IndexContractCall, IndexDiscovery, IndexEvent, IndexEventFields, IndexEventOf, IndexEventType, IndexEventTypeFilters, IndexEventsResource, IndexFeedEnvelope, IndexFeedFetcher, IndexFeedItem, IndexFtBurn, IndexFtMint, IndexFtTransfer, IndexMapDelete, IndexMapInsert, IndexMapSet, IndexMempoolTransaction, IndexNestedContractCall, IndexNftBurn, IndexNftMint, IndexNftTransfer, IndexPostCondition, IndexPox5Event, IndexPox5EventTopic, IndexPoxCycle, IndexPoxFunctionCount, IndexPrint, IndexReorg, IndexSbtcDeposit, IndexSbtcDepositDetail, IndexSbtcEvent, IndexSbtcSummary, IndexSbtcWithdrawal, IndexSbtcWithdrawalDetail, IndexSbtcWithdrawalPhase, IndexStackingAction, IndexStxBurn, IndexStxLock, IndexStxMint, IndexStxTransfer, IndexTip, IndexTransaction, IndexVarSet, InstanceClient, InstanceDiagnosis3 as InstanceDiagnosis, InstanceIssue, InstanceState, InstanceStatus, InsufficientArchiveCreditsError, LOCAL_API_URL, LoadedArchive, MemoryEtagCache, MempoolEnvelope, MempoolListParams, MempoolTransactionEnvelope, MempoolWalkParams, NftTransfer, NftTransferEvent, NftTransferPayload2 as NftTransferPayload, NftTransfersEnvelope, NftTransfersListParams, NftTransfersResource, NftTransfersWalkParams, Pox5EventsEnvelope, Pox5EventsListParams, Pox5EventsWalkParams, Pox5Resource, PoxCycleEnvelope, PoxCyclesEnvelope, PoxCyclesListParams, PoxCyclesWalkParams, PoxResource, PrintSchemaResponse, PublicStatus2 as PublicStatus, RateLimitError, ReplayResult2 as ReplayResult, RequestOptions, RewardSet2 as RewardSet, RotateSecretResponse2 as RotateSecretResponse, SbtcDepositEnvelope, SbtcDepositEvent, SbtcDepositsConsumeParams, SbtcDepositsEnvelope, SbtcDepositsListParams, SbtcDepositsWalkParams, SbtcEventTopic2 as SbtcEventTopic, SbtcEventsConsumeParams, SbtcEventsEnvelope, SbtcEventsListParams, SbtcEventsWalkParams, SbtcResource, SbtcSummaryEnvelope, SbtcWithdrawalEnvelope, SbtcWithdrawalEvent, SbtcWithdrawalStatus, SbtcWithdrawalSweptConfirmedEvent, SbtcWithdrawalsEnvelope, SbtcWithdrawalsListParams, SbtcWithdrawalsWalkParams, SecondLayer, SecondLayerArchive, SecondLayerError, SecondLayerErrorOptions, SecondLayerOptions, SinkTx, StackingEnvelope, StackingListParams, StackingWalkParams, StandardWebhooksHeaders2 as StandardWebhooksHeaders, StreamsBatch, StreamsBatchContext, StreamsCanonicalBlock, StreamsClient, StreamsConsumeParams, StreamsDumpFile, StreamsDumps, StreamsDumpsManifest, StreamsEvent, StreamsEventPayload, StreamsEventType, StreamsEventsConsumeParams, StreamsEventsConsumeResult, StreamsEventsEnvelope, StreamsEventsListEnvelope, StreamsEventsListParams, StreamsEventsStreamParams, StreamsEventsSubscribeParams, StreamsReorg, StreamsReorgContext, StreamsReorgsListEnvelope, StreamsReorgsListParams, StreamsServerError, StreamsSignatureError, StreamsSubscription, StreamsTip, StreamsWireEvent2 as StreamsWireEvent, SubgraphAgentSchema3 as SubgraphAgentSchema, SubgraphOperationStatus, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphSpecOptions3 as SubgraphSpecOptions, Subgraphs, TransactionEnvelope, TransactionProof, TransactionProofVerifyResult, TransactionsEnvelope, TransactionsListParams, TransactionsWalkParams, UpdateWebhookRequest2 as UpdateWebhookRequest, ValidationError, VmStreamsEvent, WalkOptions, WebhookDetail2 as WebhookDetail, WebhookFormat, WebhookHeaderInput, WebhookKind, WebhookRuntime, WebhookStatus, WebhookSummary2 as WebhookSummary, WebhookTestResult2 as WebhookTestResult, Webhooks, WithSinkTx, consumeIndexFeed, consumerHealth, contextField, createArchiveClient, createStreamsClient, decode, decodeChainWebhook, decodeClarityValue, decodeFtBurn, decodeFtMint, decodeFtTransfer, decodeNftBurn, decodeNftMint, decodeNftTransfer, decodePrint, decodeStxBurn, decodeStxLock, decodeStxMint, decodeStxTransfer, fetchRewardSet, getSubgraph, isFtBurn, isFtMint, isFtTransfer, isNftBurn, isNftMint, isNftTransfer, isPrint, isStxBurn, isStxLock, isStxMint, isStxTransfer, parseRetryAfter, resolveAccountKey, resolveApiKey, resolveBaseUrl, shutdownSignal, toJsonSafe, trigger, verifySecondlayerSignature, verify as verifyStandardWebhooksHeaders, verifyTransactionProof, verifyWebhookSignature };