@secondlayer/sdk 6.46.1 → 6.48.0

package/dist/streams/index.d.ts

@@ -14,12 +14,83 @@ import { STREAMS_EVENT_TYPES, StreamsEventType } from "@secondlayer/shared";
 * The interface is dependency-free on purpose: implementations with real
 * database drivers live behind subpath exports (`@secondlayer/sdk/sinks/*`)
 * so the root entry ships no DB dependency.
+*
+* ## The contract
+*
+* Binding on every implementation; the conformance kit
+* (`@secondlayer/sdk/sinks/testing`) probes each one. Violations are SILENT
+* in production — they surface as gaps or duplicates weeks later, never as
+* errors at the violation site — which is why they are spelled out here and
+* mechanically tested.
+*
+* What the loop guarantees the sink:
+*
+* 1. **Init-before-first-page.** `loadCursor` is called exactly once, before
+*    the first fetch — even when the caller passed an explicit `fromCursor`.
+*    It is the sink's init hook: create checkpoint storage, validate
+*    rollback preconditions.
+* 2. **Deterministic replay.** Re-reading from the same cursor yields the
+*    same rows in the same order. `cursor` is therefore a valid idempotency
+*    key: an append-only sink can dedup on it with no contract change.
+* 3. **At-least-once delivery.** A batch whose commit outcome was lost (crash
+*    after commit, before the loop observed it) is re-committed on restart
+*    with the SAME cursor and the same rows.
+*
+* What the sink must guarantee — `commitBatch`:
+*
+* 4. **Rows+cursor atomicity.** The handler's writes and `cursor` commit in
+*    ONE transaction. Committing them separately is the classic torn-batch
+*    bug: a crash between the two either re-delivers (duplicates) or skips
+*    (gap) depending on the order.
+* 5. **Abort on throw.** A throw from `write` aborts the WHOLE transaction —
+*    neither rows nor cursor land — so a crashed batch is simply re-read.
+* 6. **The lent transaction is the real one.** `write(tx)` receives the same
+*    live transaction the cursor commits in; every handler write must go
+*    through it. Writes outside `tx` escape atomicity AND rollback.
+* 7. **Replay safety.** Committing the same cursor twice must not corrupt
+*    state (per #3 the rows are identical; upsert/dedup make it exact).
+*
+* What the sink must guarantee — `rollback`:
+*
+* 8. **Delete+rewind atomicity.** Undoing rows at/above the fork and
+*    committing `rewindCursor` happen in ONE transaction. A crash between
+*    them resumes above the fork and the deleted range is never re-read —
+*    the silent-gap bug.
+* 9. **Inclusive fork point.** Undo AT OR ABOVE `forkPointHeight` (`>=`) —
+*    the new canonical chain re-supplies the fork block itself.
+* 10. **Idempotent.** The loop may re-apply the same rollback after a crash
+*     (reorgs are deduped in memory only); a second application must be a
+*     harmless no-op.
+* 11. **Scope by height, not cursor.** On a page reporting several forks the
+*     loop calls `rollback` once per fork: each call carries its own
+*     `forkPointHeight` but ALL carry the same `rewindCursor` (the lowest
+*     fork point). Derive the undo range from `forkPointHeight` only; a
+*     sink that derives it from `rewindCursor` under-deletes silently.
+*
+* Error semantics and concurrency:
+*
+* 12. **Throw, don't swallow; no internal retry.** The loop owns retry
+*     policy. A swallowed commit error advances the loop past unwritten
+*     data; an internal retry can double-apply around a partial failure.
+* 13. **Single writer per checkpoint id.** The loop assumes one live
+*     consumer per checkpoint identity. A sink that can detect a second
+*     writer (e.g. a lock) must fail loudly — never block or interleave.
 */
 interface ConsumerSink<Tx = unknown> {
 	/** Phantom marker carrying `Tx` in a directly-inferable position, so the
 	*  consume loops' `TTx` type parameter resolves from the `sink` option
 	*  (never set at runtime). */
 	readonly _tx?: Tx;
+	/** Static capabilities, read by the loop before the first fetch to fail
+	*  fast on impossible pairings. */
+	readonly capabilities?: {
+		/** This sink cannot undo committed rows (append-only store, ClickHouse,
+		*  parquet, …), so `rollback` is unimplementable and following the
+		*  unfinalized tip would corrupt it on the first fork. The loop throws
+		*  loudly unless consuming with `finalizedOnly: true` — in that mode
+		*  reorgs never reach the sink and `rollback` may simply throw. */
+		finalizedOnly?: boolean;
+	};
 	/** The committed checkpoint, or `null` on first run. Called once, before
 	*  the first page. Implementations may create their checkpoint storage
 	*  here and SHOULD validate their rollback preconditions (e.g. that every
@@ -39,6 +110,11 @@ interface ConsumerSink<Tx = unknown> {
 	* without the rewound cursor is the classic silent-gap bug: a crash
 	* between the two writes resumes above the fork and the deleted range is
 	* never re-read.
+	*
+	* On a multi-fork page this is called once PER fork, every call with the
+	* same `rewindCursor` (the lowest fork point) but its own
+	* `forkPointHeight` — scope the undo by `forkPointHeight` only (contract
+	* invariant #11), and expect re-application after a crash (#10).
 	*/
 	rollback(forkPointHeight: number, rewindCursor: string): Promise<void>;
 }
@@ -46,97 +122,97 @@ interface ConsumerSink<Tx = unknown> {
 *  is unchanged (an intersection with `unknown` is an identity, so
 *  contextual typing of `onBatch` callbacks never degrades to a union). */
 type WithSinkTx<TTx> = [TTx] extends [never] ? unknown : {
-	tx: TTx
+	tx: TTx;
 };
 type IndexEventBase = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
 	/** Submitting-transaction context, present only when `txContext: true` was
 	*  requested. `tx_sender` is the real tx sender — distinct from a transfer's
 	*  asset `sender`, and the only place a `print` event's sender is available.
 	*  Lets a consumer build per-event tx context without a `/v1/index/transactions`
 	*  call per event. */
-	tx_sender?: string | null
-	tx_type?: string | null
-	tx_status?: string | null
-	tx_contract_id?: string | null
-	tx_function_name?: string | null
+	tx_sender?: string | null;
+	tx_type?: string | null;
+	tx_status?: string | null;
+	tx_contract_id?: string | null;
+	tx_function_name?: string | null;
 };
 type IndexFtTransfer = IndexEventBase & {
-	event_type: "ft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	event_type: "ft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type IndexNftTransfer = IndexEventBase & {
-	event_type: "nft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+	event_type: "nft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type IndexStxTransfer = IndexEventBase & {
-	event_type: "stx_transfer"
-	sender: string
-	recipient: string
-	amount: string
-	memo: string | null
+	event_type: "stx_transfer";
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo: string | null;
 };
 type IndexStxMint = IndexEventBase & {
-	event_type: "stx_mint"
-	recipient: string
-	amount: string
+	event_type: "stx_mint";
+	recipient: string;
+	amount: string;
 };
 type IndexStxBurn = IndexEventBase & {
-	event_type: "stx_burn"
-	sender: string
-	amount: string
+	event_type: "stx_burn";
+	sender: string;
+	amount: string;
 };
 type IndexStxLock = IndexEventBase & {
-	event_type: "stx_lock"
-	sender: string
-	amount: string
+	event_type: "stx_lock";
+	sender: string;
+	amount: string;
 	payload: {
-		unlock_height: string | null
-	}
+		unlock_height: string | null;
+	};
 };
 type IndexFtMint = IndexEventBase & {
-	event_type: "ft_mint"
-	asset_identifier: string
-	recipient: string
-	amount: string
+	event_type: "ft_mint";
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type IndexFtBurn = IndexEventBase & {
-	event_type: "ft_burn"
-	asset_identifier: string
-	sender: string
-	amount: string
+	event_type: "ft_burn";
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type IndexNftMint = IndexEventBase & {
-	event_type: "nft_mint"
-	asset_identifier: string
-	recipient: string
-	value: string
+	event_type: "nft_mint";
+	asset_identifier: string;
+	recipient: string;
+	value: string;
 };
 type IndexNftBurn = IndexEventBase & {
-	event_type: "nft_burn"
-	asset_identifier: string
-	sender: string
-	value: string
+	event_type: "nft_burn";
+	asset_identifier: string;
+	sender: string;
+	value: string;
 };
 type IndexPrint = IndexEventBase & {
-	event_type: "print"
+	event_type: "print";
 	payload: {
-		topic: string | null
-		value: unknown
-		raw_value: string | null
-	}
+		topic: string | null;
+		value: unknown;
+		raw_value: string | null;
+	};
 };
 /** Decoded chain event, discriminated by `event_type`. */
 type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexStxLock | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
@@ -144,68 +220,68 @@ type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexS
 *  object carrying that hex (`{ hex }`), or a decoded Clarity-JSON object.
 *  Decode helpers (`decodeNftTransfer`, etc.) resolve it to a concrete value. */
 type StreamsClarityValue = string | {
-	hex: string
+	hex: string;
 } | Record<string, unknown>;
 type StxTransferPayload = {
-	sender: string
-	recipient: string
-	amount: string
-	memo?: string
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo?: string;
 };
 type StxMintPayload = {
-	recipient: string
-	amount: string
+	recipient: string;
+	amount: string;
 };
 type StxBurnPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 };
 type StxLockPayload = {
-	locked_address: string
-	locked_amount: string
-	unlock_height: string
+	locked_address: string;
+	locked_amount: string;
+	unlock_height: string;
 };
 type FtTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type FtMintPayload = {
-	asset_identifier: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type FtBurnPayload = {
-	asset_identifier: string
-	sender: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type NftTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: StreamsClarityValue
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: StreamsClarityValue;
 	/** Canonical serialized hex of `value`, when the stream carries it. */
-	raw_value?: string
+	raw_value?: string;
 };
 type NftMintPayload = {
-	asset_identifier: string
-	recipient: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	recipient: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type NftBurnPayload = {
-	asset_identifier: string
-	sender: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	sender: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type PrintPayload = {
-	contract_id?: string | null
-	topic?: string
-	value?: unknown
-	raw_value?: string
+	contract_id?: string | null;
+	topic?: string;
+	value?: unknown;
+	raw_value?: string;
 };
 /** Union of every Streams payload shape, discriminated by `event_type` on the
 *  parent `StreamsEvent`. */
@@ -216,92 +292,97 @@ type StreamsEventBase = {
 	* it as the primary key of your projection rows — replaying a batch then
 	* upserts cleanly. Don't synthesize your own id from `tx_id`/`event_index`.
 	*/
-	cursor: string
-	block_height: number
-	block_hash: string
-	burn_block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
-	ts: string
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
+	ts: string;
 	/**
 	* True when this event's block is past the finality boundary (immutable).
 	* Optional for back-compat; the API always sets it on Streams responses.
 	*/
-	finalized?: boolean
+	finalized?: boolean;
 	/**
 	* Labels whose filter group this event satisfied, present only when the
 	* request used a labelled `filters` map. The SDK dispatches on it for you
 	* (`on.<label>`), so handlers rarely read it directly.
 	*/
-	matched?: string[]
+	matched?: string[];
 };
 type StreamsEventOf<
 	T extends StreamsEventType,
 	P
 > = StreamsEventBase & {
-	event_type: T
-	payload: P
+	event_type: T;
+	payload: P;
 };
 /** A raw Streams event. Discriminated on `event_type`, so `event.payload`
 *  narrows to the matching payload shape once the type is checked. */
 type StreamsEvent = StreamsEventOf<"stx_transfer", StxTransferPayload> | StreamsEventOf<"stx_mint", StxMintPayload> | StreamsEventOf<"stx_burn", StxBurnPayload> | StreamsEventOf<"stx_lock", StxLockPayload> | StreamsEventOf<"ft_transfer", FtTransferPayload> | StreamsEventOf<"ft_mint", FtMintPayload> | StreamsEventOf<"ft_burn", FtBurnPayload> | StreamsEventOf<"nft_transfer", NftTransferPayload> | StreamsEventOf<"nft_mint", NftMintPayload> | StreamsEventOf<"nft_burn", NftBurnPayload> | StreamsEventOf<"print", PrintPayload>;
 type StreamsTip = {
-	block_height: number
-	block_hash: string
-	burn_block_height: number
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
 	/**
 	* Highest Stacks block past the burn-confirmation finality boundary.
 	* Optional for back-compat; the API always sets it.
 	*/
-	finalized_height?: number
-	lag_seconds: number
+	finalized_height?: number;
+	lag_seconds: number;
 	/**
 	* Oldest height still seekable on the live API for the caller's tier
 	* (`tip - retention`). `null` = unlimited retention. Older reads must use the
 	* cold dumps lane. Optional for back-compat.
 	*/
-	oldest_seekable_height?: number | null
+	oldest_seekable_height?: number | null;
 	/** Oldest seekable cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
-	oldest_cursor?: string | null
+	oldest_cursor?: string | null;
 };
 type StreamsCanonicalBlock = {
-	block_height: number
-	block_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
-	is_canonical: true
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
+	is_canonical: true;
 };
 type StreamsReorg = {
-	detected_at: string
-	fork_point_height: number
+	detected_at: string;
+	fork_point_height: number;
 	orphaned_range: {
-		from: string
-		to: string
-	}
+		from: string;
+		to: string;
+	};
 	/**
 	* First position of the new canonical chain at the fork, `fork:0`
 	* (INCLUSIVE). Not an exclusive resume token — resuming directly from it
 	* skips `fork:0`. The consumer rewinds to the foot of `fork_point_height`
 	* (`Cursor.atHeight`) to re-read the new run from `fork:0` inclusive.
 	*/
-	new_canonical_tip: string
+	new_canonical_tip: string;
 };
-type StreamsEventsEnvelope = {
-	events: StreamsEvent[]
-	next_cursor: string | null
-	tip: StreamsTip
-	reorgs: StreamsReorg[]
+type StreamsEventsEnvelope<TEvent = StreamsEvent> = {
+	events: TEvent[];
+	next_cursor: string | null;
+	tip: StreamsTip;
+	reorgs: StreamsReorg[];
 };
 type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
+/** The StreamsEvent union narrowed to a `types` selection — what a
+*  const-generic `types: ["ft_transfer"]` buys at the type level. */
+type StreamsEventOfTypes<T extends readonly StreamsEventType[]> = Extract<StreamsEvent, {
+	event_type: T[number];
+}>;
 type StreamsReorgsListParams = {
-	since: string
-	limit?: number
+	since: string;
+	limit?: number;
 };
 type StreamsReorgsListEnvelope = {
-	reorgs: StreamsReorg[]
-	next_since: string | null
+	reorgs: StreamsReorg[];
+	next_since: string | null;
 };
 /** A filter that matches a single value or any value in a list. */
 type StreamsFilterValue = string | readonly string[];
@@ -310,11 +391,11 @@ type StreamsFilterValue = string | readonly string[];
 * map OR together server-side.
 */
 type StreamsLabelledFilter = {
-	types?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	types?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 };
 /** A map of label → filter group. Labels are yours; the server echoes them. */
 type StreamsFilterMap = Record<string, StreamsLabelledFilter>;
@@ -327,65 +408,65 @@ type StreamsEventForFilter<
 	F,
 	D extends boolean = false
 > = F extends {
-	types: readonly (infer T extends StreamsEventType)[]
+	types: readonly (infer T extends StreamsEventType)[];
 } ? D extends true ? Extract<IndexEvent, {
-	event_type: T
+	event_type: T;
 }> : Extract<StreamsEvent, {
-	event_type: T
+	event_type: T;
 }> : D extends true ? IndexEvent : StreamsEvent;
 type StreamsEventsListParams = {
-	cursor?: string | null
-	fromHeight?: number
-	toHeight?: number
-	types?: readonly StreamsEventType[]
+	cursor?: string | null;
+	fromHeight?: number;
+	toHeight?: number;
+	types?: readonly StreamsEventType[];
 	/** Event types to exclude (applied after `types`). */
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in one scan and each
 	* returned event carries the labels it matched (`event.matched`) — two
 	* unrelated concerns share one page, one cursor, one checkpoint.
 	*/
-	filters?: StreamsFilterMap
-	limit?: number
+	filters?: StreamsFilterMap;
+	limit?: number;
 };
 type StreamsEventsStreamParams = {
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	filters?: StreamsFilterMap;
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 type StreamsEventsSubscribeParams = {
 	/** Resume strictly after this cursor; omit to live-tail from the tip. */
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
+	filters?: StreamsFilterMap;
 	/** Abort to unsubscribe (the returned function does the same). */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 	/** Called for each pushed event, in order. */
-	onEvent: (event: StreamsEvent) => void | Promise<void>
+	onEvent: (event: StreamsEvent) => void | Promise<void>;
 	/** Called on a connection error; the subscription auto-reconnects from the
 	*  last delivered cursor unless the signal has aborted. */
-	onError?: (err: unknown) => void
+	onError?: (err: unknown) => void;
 };
 /**
 * The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
@@ -412,14 +493,14 @@ type ConsumerBatchContext<
 	TReorg = unknown
 > = {
 	/** Checkpoint to commit alongside your rows. */
-	cursor: string | null
+	cursor: string | null;
 	/** Highest canonical block the sweep has reached. `null` before the first
 	*  row of a fresh consume. */
-	height: number | null
+	height: number | null;
 	/** Chain tip as of this page's read. */
-	tipHeight: number
+	tipHeight: number;
 	/** `tipHeight - height`, floored at 0. `null` until `height` is known. */
-	blocksBehind: number | null
+	blocksBehind: number | null;
 	/**
 	* The full tip for this page — `StreamsTip` or `IndexTip` depending on the
 	* surface. Exposed here so a handler never needs the `envelope` parameter,
@@ -427,12 +508,12 @@ type ConsumerBatchContext<
 	* `finalizedOnly` mistake becomes reachable (`return envelope.next_cursor`
 	* jumps the cursor past events that were filtered out and never delivered).
 	*/
-	tip: TTip
+	tip: TTip;
 	/**
 	* Reorgs reported alongside this page; empty when none. Rollback still
 	* belongs in `onReorg` — this is for observability inside a batch.
 	*/
-	reorgs: readonly TReorg[]
+	reorgs: readonly TReorg[];
 };
 /** @deprecated Use {@link ConsumerBatchContext} — the Index and Streams loops
 *  share one shape now. Kept as an alias so existing annotations compile. */
@@ -442,20 +523,20 @@ type StreamsBatchContext = ConsumerBatchContext;
 * inside the same transaction as your rollback so the two commit atomically.
 */
 type StreamsReorgContext = {
-	cursor: string
+	cursor: string;
 };
 type StreamsEventsConsumeParams<
 	TTx = never,
 	D extends boolean = false,
 	F extends StreamsFilterMap = Record<never, never>
 > = {
-	fromCursor?: string | null
+	fromCursor?: string | null;
 	/**
 	* Deliver events pre-decoded as the flat, `event_type`-discriminated rows
 	* Index serves (`IndexEvent`), so Streams consumption reads identically
 	* to Index consumption — no guard+decode pairs in your handler.
 	*/
-	decoded?: D
+	decoded?: D;
 	/**
 	* Destination adapter that owns the checkpoint + rollback transaction
 	* (e.g. `kyselySink` from `@secondlayer/sdk/sinks/kysely`). With a sink:
@@ -464,29 +545,29 @@ type StreamsEventsConsumeParams<
 	* transaction), reorg rollback is automatic, and `onBatch`'s return value
 	* is ignored.
 	*/
-	sink?: ConsumerSink<TTx>
+	sink?: ConsumerSink<TTx>;
 	/** Fires once per page, before `onBatch` and before any early return. */
-	onProgress?: (ctx: ConsumerBatchContext) => void
-	mode?: "tail" | "bounded"
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	mode?: "tail" | "bounded";
 	/**
 	* Emit only finalized (immutable) events and never surface reorgs. The SDK
 	* checkpoints at the last finalized event and re-reads the unfinalized tail
 	* until it settles. Trades finality lag for zero reorg handling; `onReorg` is
 	* ignored.
 	*/
-	finalizedOnly?: boolean
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	finalizedOnly?: boolean;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in ONE server-side scan,
 	* so two unrelated concerns share one page, one cursor, and one checkpoint
 	* instead of two consume loops. Pair with `on` to handle each label.
 	*/
-	filters?: F
+	filters?: F;
 	/**
 	* One handler per label in `filters`. Every label must be handled, so
 	* adding a label is a compile error until its handler exists.
@@ -497,8 +578,8 @@ type StreamsEventsConsumeParams<
 	* labels do not interleave within a page — add `onBatch` when you need
 	* strict global order across labels.
 	*/
-	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> }
-	batchSize?: number
+	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> };
+	batchSize?: number;
 	/**
 	* Apply a page of canonical events. Persist `ctx.cursor` in the same
 	* transaction as your writes. Returning a cursor overrides `ctx.cursor` as
@@ -507,7 +588,7 @@ type StreamsEventsConsumeParams<
 	* Optional only when `on` handles the page instead; a consume call with
 	* neither throws.
 	*/
-	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>;
 	/**
 	* Roll your projection back to `reorg.fork_point_height`, persisting
 	* `ctx.cursor` in the same transaction. Called once per *new* reorg
@@ -515,127 +596,137 @@ type StreamsEventsConsumeParams<
 	* now-canonical events. Omit it to ignore reorgs (events stay canonical, but
 	* stale rows from an orphaned fork are left in place).
 	*/
-	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
 	/** Page-fetch retries after the first failure (429/5xx/network only —
 	*  4xx and handler throws always propagate). Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base retry delay in ms; the n-th retry waits `retryDelay * n`. A server
 	*  `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep (metrics/logging). */
 	onError?: (err: unknown, ctx: {
-		attempt: number
-		retriesLeft: number
-		delayMs: number
-	}) => void
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 /**
 * One yielded page from {@link StreamsClient.consume} — the
 * `GET /v1/streams/events` envelope verbatim, with `next_cursor` renamed to
 * `cursor` (the checkpoint to persist and resume from).
 */
-type StreamsBatch = {
+type StreamsBatch<TEvent = StreamsEvent> = {
 	/** Canonical events of this page, in cursor order. */
-	events: StreamsEvent[]
+	events: TEvent[];
 	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
-	cursor: string | null
-	tip: StreamsTip
+	cursor: string | null;
+	tip: StreamsTip;
 	/** Chain reorgs reported alongside this page; empty when none. */
-	reorgs: StreamsReorg[]
+	reorgs: StreamsReorg[];
 };
 type StreamsConsumeParams = {
 	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
-	cursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	cursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
+	/** Labelled OR-groups — same semantics as `events.consume`; each returned
+	*  event echoes the labels it matched. */
+	filters?: StreamsFilterMap;
 	/** Events per page (the `limit` query param). Default 100. */
-	batchSize?: number
+	batchSize?: number;
 	/** Poll interval while caught up at the tip, in ms. Default 2000. */
-	intervalMs?: number
+	intervalMs?: number;
 	/** Abort to end the iteration. */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 };
 type StreamsEventsConsumeResult = {
-	cursor: string | null
-	pages: number
-	emptyPolls: number
+	cursor: string | null;
+	pages: number;
+	emptyPolls: number;
 };
 type StreamsEventsReplayParams = {
 	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
-	from?: "genesis" | string
+	from?: "genesis" | string;
 	/**
 	* Called once per finalized dump file, in block order, before live tailing.
 	* Process the parquet with your own tooling (e.g. DuckDB) — the SDK does not
 	* decode parquet. Use `client.dumps.download(file)` to fetch + verify bytes.
 	*/
-	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void
+	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void;
 	/** Called per live page after the dump phase, like `consume`. */
-	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined;
 	/**
 	* Called when the live-tail phase (after the dump backfill) crosses a reorg,
 	* before the cursor rewinds and re-reads the now-canonical events — same
 	* contract as `consume`. The dump-backfill phase is finalized and never
 	* reorgs; omit this to leave stale rows from an orphaned fork in place.
 	*/
-	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
-	mode?: "tail" | "bounded"
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
+	mode?: "tail" | "bounded";
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
+	/** Narrow the LIVE TAIL after the dump phase. The dump files themselves are
+	*  always all-type (block-partitioned parquet) — filter those in your own
+	*  tooling while processing each file. */
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	/** Labelled OR-groups for the live tail, like `consume`. */
+	filters?: StreamsFilterMap;
 };
 type FetchLike2 = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** One bulk parquet file in the dumps manifest. `path` is the object key under
 *  the dumps base URL. */
 type StreamsDumpFile = {
-	path: string
-	from_block: number
-	to_block: number
-	min_cursor: string | null
-	max_cursor: string | null
-	row_count: number
-	byte_size: number
-	sha256: string
-	schema_version: number
-	created_at: string
+	path: string;
+	from_block: number;
+	to_block: number;
+	min_cursor: string | null;
+	max_cursor: string | null;
+	row_count: number;
+	byte_size: number;
+	sha256: string;
+	schema_version: number;
+	created_at: string;
 };
 type StreamsDumpsManifest = {
-	dataset: string
-	network: string
-	version: string
-	schema_version: number
-	generated_at: string
-	producer_version: string
-	finality_lag_blocks: number
+	dataset: string;
+	network: string;
+	version: string;
+	schema_version: number;
+	generated_at: string;
+	producer_version: string;
+	finality_lag_blocks: number;
 	/** Cursor at the end of the finalized bulk coverage — hand to live tailing. */
-	latest_finalized_cursor: string | null
+	latest_finalized_cursor: string | null;
 	coverage: {
-		from_block: number
-		to_block: number
-	}
-	files: StreamsDumpFile[]
+		from_block: number;
+		to_block: number;
+	};
+	files: StreamsDumpFile[];
 	/** ed25519 signature over the manifest's canonical bytes. Absent on legacy
 	*  unsigned manifests. Verified by `list()` when `verifyDumpsManifest` is on. */
-	signature?: string
+	signature?: string;
 	/** Short id of the signing public key. */
-	key_id?: string
+	key_id?: string;
 };
 type StreamsDumps = {
 	/** Fetch and parse the latest dumps manifest. */
-	list(): Promise<StreamsDumpsManifest>
+	list(): Promise<StreamsDumpsManifest>;
 	/** Absolute URL for a manifest file. */
-	fileUrl(file: StreamsDumpFile): string
+	fileUrl(file: StreamsDumpFile): string;
 	/** Download a parquet file and verify its sha256 against the manifest. */
-	download(file: StreamsDumpFile): Promise<Uint8Array>
+	download(file: StreamsDumpFile): Promise<Uint8Array>;
 };
 type StreamsClient = {
 	/**
@@ -652,10 +743,19 @@ type StreamsClient = {
 	* rewound automatically — use `events.consume` with `onReorg` for managed
 	* rollback semantics.
 	*/
-	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
+	/** Narrowing overload: a literal `types` array narrows every batch's
+	*  event union to exactly those members. */
+	consume<const T extends readonly StreamsEventType[]>(params: StreamsConsumeParams & {
+		types: T;
+	}): AsyncIterableIterator<StreamsBatch<StreamsEventOfTypes<T>>>;
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>;
 	events: {
-		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
-		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
+		/** Narrowing overload, matching `consume`. */
+		list<const T extends readonly StreamsEventType[]>(params: StreamsEventsListParams & {
+			types: T;
+		}): Promise<StreamsEventsEnvelope<StreamsEventOfTypes<T>>>;
+		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>;
+		byTxId(txId: string): Promise<StreamsEventsListEnvelope>;
 		/**
 		* Pull pages from Streams and call `onBatch` after each page.
 		*
@@ -670,8 +770,8 @@ type StreamsClient = {
 			TTx = never,
 			D extends boolean = false
 		>(params: StreamsEventsConsumeParams<TTx, D, F> & {
-			sink?: ConsumerSink<TTx>
-		}): Promise<StreamsEventsConsumeResult>
+			sink?: ConsumerSink<TTx>;
+		}): Promise<StreamsEventsConsumeResult>;
 		/**
 		* Backfill from bulk dumps, then continue live from the dump→live seam in
 		* one call. Iterates finalized dump files (via `onDumpFile`) in block
@@ -679,7 +779,7 @@ type StreamsClient = {
 		* (exclusive input → no gap or duplicate at the seam). Requires
 		* `dumpsBaseUrl`.
 		*/
-		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
+		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>;
 		/**
 		* Follow Streams as an async iterator.
 		*
@@ -687,49 +787,53 @@ type StreamsClient = {
 		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
 		* `maxEmptyPolls` stops it.
 		*/
-		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>
+		/** Narrowing overload, matching `consume`. */
+		stream<const T extends readonly StreamsEventType[]>(params: StreamsEventsStreamParams & {
+			types: T;
+		}): AsyncIterable<StreamsEventOfTypes<T>>;
+		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>;
 		/**
 		* Subscribe to the real-time SSE push surface. Calls `onEvent` for each new
 		* canonical event as the server pushes it (chain cadence, not poll-bounded),
 		* and verifies each frame's inline ed25519 signature when the client was
 		* created with `verify`. Returns an unsubscribe function.
 		*/
-		subscribe(params: StreamsEventsSubscribeParams): () => void
-	}
+		subscribe(params: StreamsEventsSubscribeParams): () => void;
+	};
 	blocks: {
-		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>
-	}
+		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>;
+	};
 	reorgs: {
-		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
-	}
+		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>;
+	};
 	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
-	dumps: StreamsDumps
-	canonical(height: number): Promise<StreamsCanonicalBlock>
-	tip(): Promise<StreamsTip>
+	dumps: StreamsDumps;
+	canonical(height: number): Promise<StreamsCanonicalBlock>;
+	tip(): Promise<StreamsTip>;
 	/** Your own Streams consumption (events today + this month) and tier limits. */
-	usage(): Promise<StreamsUsage>
+	usage(): Promise<StreamsUsage>;
 };
 type StreamsUsage = {
-	product: "streams"
-	tier: string
+	product: "streams";
+	tier: string;
 	limits: {
-		rate_limit_per_second: number | null
-		retention_days: number | null
-	}
+		rate_limit_per_second: number | null;
+		retention_days: number | null;
+	};
 	usage: {
-		events_today: number
-		events_this_month: number
-	}
+		events_today: number;
+		events_this_month: number;
+	};
 };
 type CreateStreamsClientOptions = {
-	apiKey: string
-	baseUrl?: string
-	fetchImpl?: FetchLike2
+	apiKey: string;
+	baseUrl?: string;
+	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
+	dumpsBaseUrl?: string;
 	/**
 	* Verify the ed25519 `X-Signature` on every REST response and per-frame SSE
 	* signature. Three states:
@@ -748,8 +852,8 @@ type CreateStreamsClientOptions = {
 	* rotated `X-Signature-KeyId` triggers one refresh) unless a PEM is pinned.
 	*/
 	verify?: boolean | {
-		publicKey: string
-	}
+		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
@@ -757,7 +861,7 @@ type CreateStreamsClientOptions = {
 	* `false` to opt out. A missing or invalid signature throws
 	* `StreamsSignatureError`.
 	*/
-	verifyDumpsManifest?: boolean
+	verifyDumpsManifest?: boolean;
 };
 declare function createStreamsClient(options: CreateStreamsClientOptions): StreamsClient;
 /**
@@ -820,14 +924,14 @@ declare class SecondLayerError extends Error {
 	*/
 	walk(fn?: (err: unknown) => boolean): unknown;
 	toJSON(): {
-		name: string
-		message: string
-		shortMessage: string
-		cause: string | undefined
-		code: string | undefined
-		docsUrl: string | undefined
-		retryable: boolean
-		retryAfterSeconds: number | undefined
+		name: string;
+		message: string;
+		shortMessage: string;
+		cause: string | undefined;
+		code: string | undefined;
+		docsUrl: string | undefined;
+		retryable: boolean;
+		retryAfterSeconds: number | undefined;
 	};
 }
 /**
@@ -861,9 +965,9 @@ declare class AuthError extends ApiError {
 *  with `retryAfterSeconds` parsed from the `Retry-After` header when sent. */
 declare class RateLimitError extends ApiError {
 	/** Raw `Retry-After` header value (seconds or HTTP-date). */
-	readonly retryAfter?: string;
+	readonly retryAfter?: string | undefined;
 	readonly status: 429;
-	constructor(message?: string, retryAfter?: string);
+	constructor(message?: string, retryAfter?: string | undefined);
 }
 /** Thrown on a 4xx the caller can fix (bad cursor, bad params). Never retried. */
 declare class ValidationError extends ApiError {
@@ -878,210 +982,210 @@ declare class StreamsSignatureError extends SecondLayerError {
 	constructor(message?: string);
 }
 type FtTransferEvent = Extract<StreamsEvent, {
-	event_type: "ft_transfer"
+	event_type: "ft_transfer";
 }>;
 type DecodedFtTransferPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type DecodedFtTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_transfer"
-	decoded_payload: DecodedFtTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_transfer";
+	decoded_payload: DecodedFtTransferPayload;
+	source_cursor: string;
 };
 declare function isFtTransfer(event: StreamsEvent): event is FtTransferEvent;
 declare function decodeFtTransfer(event: StreamsEvent): DecodedFtTransfer;
 type NftTransferEvent = Extract<StreamsEvent, {
-	event_type: "nft_transfer"
+	event_type: "nft_transfer";
 }>;
 type DecodedNftTransferPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	recipient: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type DecodedNftTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_transfer"
-	decoded_payload: DecodedNftTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_transfer";
+	decoded_payload: DecodedNftTransferPayload;
+	source_cursor: string;
 };
 declare function isNftTransfer(event: StreamsEvent): event is NftTransferEvent;
 declare function decodeNftTransfer(event: StreamsEvent): DecodedNftTransfer;
 type DecodedStxTransferPayload = {
-	sender: string
-	recipient: string
-	amount: string
-	memo: string | null
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo: string | null;
 };
 type DecodedStxTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_transfer"
-	decoded_payload: DecodedStxTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_transfer";
+	decoded_payload: DecodedStxTransferPayload;
+	source_cursor: string;
 };
 type DecodedStxMintPayload = {
-	recipient: string
-	amount: string
+	recipient: string;
+	amount: string;
 };
 type DecodedStxMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_mint"
-	decoded_payload: DecodedStxMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_mint";
+	decoded_payload: DecodedStxMintPayload;
+	source_cursor: string;
 };
 type DecodedStxBurnPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 };
 type DecodedStxBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_burn"
-	decoded_payload: DecodedStxBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_burn";
+	decoded_payload: DecodedStxBurnPayload;
+	source_cursor: string;
 };
 declare function isStxTransfer(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_transfer"
+	event_type: "stx_transfer";
 };
 declare function decodeStxTransfer(event: StreamsEvent): DecodedStxTransfer;
 declare function isStxMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_mint"
+	event_type: "stx_mint";
 };
 declare function decodeStxMint(event: StreamsEvent): DecodedStxMint;
 declare function isStxBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_burn"
+	event_type: "stx_burn";
 };
 declare function decodeStxBurn(event: StreamsEvent): DecodedStxBurn;
 type DecodedStxLockPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 	payload: {
-		unlock_height: string | null
-	}
+		unlock_height: string | null;
+	};
 };
 type DecodedStxLock = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_lock"
-	decoded_payload: DecodedStxLockPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_lock";
+	decoded_payload: DecodedStxLockPayload;
+	source_cursor: string;
 };
 declare function isStxLock(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_lock"
+	event_type: "stx_lock";
 };
 declare function decodeStxLock(event: StreamsEvent): DecodedStxLock;
 type DecodedFtMintPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	recipient: string;
+	amount: string;
 };
 type DecodedFtMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_mint"
-	decoded_payload: DecodedFtMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_mint";
+	decoded_payload: DecodedFtMintPayload;
+	source_cursor: string;
 };
 type DecodedFtBurnPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	amount: string;
 };
 type DecodedFtBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_burn"
-	decoded_payload: DecodedFtBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_burn";
+	decoded_payload: DecodedFtBurnPayload;
+	source_cursor: string;
 };
 type DecodedNftMintPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	recipient: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	recipient: string;
+	value: string;
 };
 type DecodedNftMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_mint"
-	decoded_payload: DecodedNftMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_mint";
+	decoded_payload: DecodedNftMintPayload;
+	source_cursor: string;
 };
 type DecodedNftBurnPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	value: string;
 };
 type DecodedNftBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_burn"
-	decoded_payload: DecodedNftBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_burn";
+	decoded_payload: DecodedNftBurnPayload;
+	source_cursor: string;
 };
 declare function isFtMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "ft_mint"
+	event_type: "ft_mint";
 };
 declare function decodeFtMint(event: StreamsEvent): DecodedFtMint;
 declare function isFtBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "ft_burn"
+	event_type: "ft_burn";
 };
 declare function decodeFtBurn(event: StreamsEvent): DecodedFtBurn;
 declare function isNftMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "nft_mint"
+	event_type: "nft_mint";
 };
 declare function decodeNftMint(event: StreamsEvent): DecodedNftMint;
 declare function isNftBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "nft_burn"
+	event_type: "nft_burn";
 };
 declare function decodeNftBurn(event: StreamsEvent): DecodedNftBurn;
 /** Decoded form of a Clarity `print` event:
@@ -1090,41 +1194,41 @@ declare function decodeNftBurn(event: StreamsEvent): DecodedNftBurn;
 *    `0x…` hex, tuples as objects)
 *  - `raw_value`: the canonical serialized hex, for byte-exact consumers */
 type DecodedPrintValue = {
-	topic: string | null
-	value: unknown
-	raw_value: string | null
+	topic: string | null;
+	value: unknown;
+	raw_value: string | null;
 };
 type DecodedPrintPayload = {
-	contract_id: string | null
-	payload: DecodedPrintValue
+	contract_id: string | null;
+	payload: DecodedPrintValue;
 };
 type DecodedPrint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "print"
-	decoded_payload: DecodedPrintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "print";
+	decoded_payload: DecodedPrintPayload;
+	source_cursor: string;
 };
 declare function isPrint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "print"
+	event_type: "print";
 };
 declare function decodePrint(event: StreamsEvent): DecodedPrint;
 /** Superset of the columns the decoded_events table holds. Every decoded
 *  event's `decoded_payload` is assignable to this, so the indexer's writer
 *  can map columns generically instead of per-event-type. */
 type DecodedEventColumns = {
-	contract_id?: string | null
-	asset_identifier?: string | null
-	sender?: string | null
-	recipient?: string | null
-	amount?: string | null
-	value?: string | null
-	memo?: string | null
+	contract_id?: string | null;
+	asset_identifier?: string | null;
+	sender?: string | null;
+	recipient?: string | null;
+	amount?: string | null;
+	value?: string | null;
+	memo?: string | null;
 	/** JSONB overflow for non-flat types (e.g. print's decoded value). */
-	payload?: unknown
+	payload?: unknown;
 };
 /**
 * Helpers for Streams cursors. A cursor is the opaque `<block>:<index>` string
@@ -1149,12 +1253,12 @@ declare const Cursor: {
 	* type), larger than any real index, so nothing at `height - 1` survives the
 	* keyset and the next returned row is exactly `(height, 0)`.
 	*/
-	atHeight(height: number): string
+	atHeight(height: number): string;
 	/** Parse a `<block>:<index>` cursor. Throws `ValidationError` if malformed. */
 	parse(cursor: string): {
-		blockHeight: number
-		eventIndex: number
-	}
+		blockHeight: number;
+		eventIndex: number;
+	};
 };
 type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
 export { isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decode, createStreamsClient, ValidationError, StreamsUsage, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsSubscribeParams, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsConsumeParams, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StreamsBatch, STREAMS_EVENT_TYPES, RateLimitError, NftTransferPayload, NftTransferEvent, FtTransferPayload, FtTransferEvent, FetchLike2 as FetchLike, 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, Cursor, ConsumerBatchContext, AuthError };