@thru/indexer 0.1.38

package/dist/index.d.cts

@@ -0,0 +1,1064 @@
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { PgTableWithColumns, PgColumn } from 'drizzle-orm/pg-core';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { z } from 'zod';
+import { Filter, Event, AccountState, ChainClientFactory } from '@thru/replay';
+import { OpenAPIHono, z as z$1 } from '@hono/zod-openapi';
+
+/**
+ * Schema type definitions with improved type safety.
+ * Uses branded types and conditional inference for better DX.
+ */
+
+/** Supported column data types */
+type ColumnType = "text" | "bigint" | "integer" | "boolean" | "timestamp";
+/** Internal modifiers for a column definition */
+interface ColumnModifiers<T, TNull extends boolean = boolean> {
+    /** Phantom type for inference */
+    readonly _type: T;
+    /** Whether the column allows null - literal type for proper inference */
+    readonly _nullable: TNull;
+    /** Whether the column is indexed */
+    readonly _indexed: boolean;
+    /** Whether the column has a unique constraint */
+    readonly _unique: boolean;
+    /** Whether the column is the primary key */
+    readonly _primary: boolean;
+    /** Default value for the column */
+    readonly _default?: T;
+    /** Whether to use current timestamp as default */
+    readonly _defaultNow?: boolean;
+    /** Foreign key reference */
+    readonly _references?: {
+        table: PgTableWithColumns<any>;
+        column: string;
+    };
+    /** The underlying column type */
+    readonly _columnType: ColumnType;
+}
+/** A column definition with fluent modifiers */
+interface ColumnDef<T, TNull extends boolean = true> extends ColumnModifiers<T, TNull> {
+    /** Mark column as NOT NULL - changes the type to non-nullable */
+    notNull(): ColumnDef<T, false>;
+    /** Add an index on this column */
+    index(): ColumnDef<T, TNull>;
+    /** Add a unique constraint */
+    unique(): ColumnDef<T, TNull>;
+    /** Mark as primary key (implies NOT NULL) */
+    primaryKey(): ColumnDef<T, false>;
+    /** Set a default value */
+    default(value: T): ColumnDef<T, TNull>;
+    /** Use current timestamp as default (only for timestamp columns) */
+    defaultNow(): ColumnDef<T, TNull>;
+    /** Add a foreign key reference */
+    references<TTable extends PgTableWithColumns<any>>(table: TTable | (() => TTable), column: keyof TTable["_"]["columns"]): ColumnDef<T, TNull>;
+}
+/** Any column definition (for generic constraints) */
+type AnyColumnDef = ColumnDef<unknown, boolean>;
+/** A schema is a record of column definitions */
+type SchemaDefinition = Record<string, AnyColumnDef>;
+/**
+ * Infer the row type from a schema definition.
+ * Handles nullable columns and preserves exact types.
+ * Uses conditional type to check the literal `_nullable` type parameter.
+ */
+type InferRow<TSchema extends SchemaDefinition> = {
+    [K in keyof TSchema]: TSchema[K] extends ColumnDef<infer T, infer TNull> ? TNull extends false ? T : T | null : never;
+};
+/**
+ * Infer the insert type from a schema definition.
+ * Makes fields optional if they have defaults or are nullable.
+ */
+type InferInsert<TSchema extends SchemaDefinition> = {
+    [K in keyof TSchema as TSchema[K] extends ColumnDef<unknown, false> ? TSchema[K]["_default"] extends undefined ? TSchema[K]["_defaultNow"] extends true ? never : K : never : never]: TSchema[K] extends ColumnDef<infer T, infer _TNull> ? T : never;
+} & {
+    [K in keyof TSchema as TSchema[K] extends ColumnDef<unknown, true> ? K : TSchema[K]["_default"] extends undefined ? TSchema[K]["_defaultNow"] extends true ? K : never : K]?: TSchema[K] extends ColumnDef<infer T, infer _TNull> ? T | null : never;
+};
+/**
+ * Column accessors for use with Drizzle operators (eq, inArray, etc.).
+ * Maps field names to Drizzle column references.
+ *
+ * Note: We use `any` here because the full PgColumn type is complex
+ * and varies based on many internal Drizzle factors. The column
+ * references work correctly at runtime for use with eq(), inArray(), etc.
+ */
+type Columns<TSchema extends SchemaDefinition> = {
+    [K in keyof TSchema]: PgColumn<any>;
+};
+
+/** Database client type - generic to work with any schema */
+type DatabaseClient = PostgresJsDatabase<Record<string, unknown>>;
+
+/**
+ * Fluent column builder API for defining schemas.
+ * Exports a global `t` object for concise schema definitions.
+ *
+ * @example
+ * ```ts
+ * import { t } from "@thru/indexer";
+ *
+ * const schema = {
+ *   id: t.text().primaryKey(),
+ *   slot: t.bigint().notNull().index(),
+ *   amount: t.bigint().notNull(),
+ *   timestamp: t.timestamp(),
+ * };
+ * ```
+ */
+
+/**
+ * Interface for the column builder.
+ * Each method creates a new column definition of the appropriate type.
+ */
+interface ColumnBuilder {
+    /** Text column (varchar) */
+    text(): ColumnDef<string, true>;
+    /** BigInt column (64-bit integer) - use for slots, amounts */
+    bigint(): ColumnDef<bigint, true>;
+    /** Integer column (32-bit) */
+    integer(): ColumnDef<number, true>;
+    /** Boolean column */
+    boolean(): ColumnDef<boolean, true>;
+    /** Timestamp column with timezone */
+    timestamp(): ColumnDef<Date, true>;
+}
+/**
+ * Global column builder for defining schemas.
+ *
+ * @example
+ * ```ts
+ * const schema = {
+ *   id: t.text().primaryKey(),
+ *   slot: t.bigint().notNull().index(),
+ *   name: t.text(),
+ *   active: t.boolean().notNull().default(true),
+ *   createdAt: t.timestamp().notNull().defaultNow(),
+ * };
+ * ```
+ */
+declare const t: ColumnBuilder;
+/**
+ * Alternative export for the column builder.
+ * Same as `t` but with a more descriptive name.
+ */
+declare const columnBuilder: ColumnBuilder;
+
+/**
+ * Runtime validation for parsed data.
+ * Generates Zod schemas from column definitions for validation.
+ */
+
+/**
+ * Generate a Zod schema from column definitions.
+ * Used for runtime validation of parse output.
+ */
+declare function generateZodSchema<TSchema extends SchemaDefinition>(schema: TSchema): z.ZodObject<any>;
+/**
+ * Validate parsed data against schema.
+ * Returns validation result with detailed errors.
+ */
+declare function validateParsedData<TSchema extends SchemaDefinition>(schema: TSchema, data: unknown, streamName: string): {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    error: string;
+};
+
+/**
+ * Shared types for the indexer library.
+ */
+
+/**
+ * API configuration for route generation.
+ * Used by event streams, account streams, and tables.
+ */
+interface ApiConfig {
+    /** Enable API routes (default: true) */
+    enabled?: boolean;
+    /** Fields that can be filtered via query params */
+    filters?: string[];
+    /** Primary key field name (default: "id" for event streams, "address" for account streams) */
+    idField?: string;
+}
+/**
+ * A batch of parsed events ready to commit.
+ * Used by the stream processor for batching before database writes.
+ */
+interface StreamBatch<T = unknown> {
+    /** The slot these events belong to */
+    slot: bigint;
+    /** The parsed events in this batch */
+    events: T[];
+}
+/**
+ * Context passed to stream hooks (filterBatch, onCommit).
+ */
+interface HookContext {
+    /** Database client for queries */
+    db: DatabaseClient;
+}
+
+/**
+ * Event stream type definitions.
+ */
+
+/**
+ * Definition input for creating an event stream.
+ * This is what users pass to defineEventStream().
+ */
+interface EventStreamDefinition<TSchema extends SchemaDefinition> {
+    /** Unique stream name (used for table name, checkpointing) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /**
+     * Schema definition using the column builder.
+     * Defines the structure of the indexed event data.
+     *
+     * @example
+     * ```ts
+     * schema: {
+     *   id: t.text().primaryKey(),
+     *   slot: t.bigint().notNull().index(),
+     *   amount: t.bigint().notNull(),
+     * }
+     * ```
+     */
+    schema: TSchema;
+    /**
+     * CEL filter for @thru/replay.
+     * Determines which events this stream receives.
+     *
+     * Use `filter` for direct filter values, or `filterFactory` for lazy loading
+     * (required for drizzle-kit compatibility when config isn't available at import time).
+     *
+     * @example
+     * ```ts
+     * // Direct filter (simpler, but requires config at import time)
+     * filter: create(FilterSchema, {
+     *   expression: "event.program.value == params.address",
+     *   params: { address: ... }
+     * })
+     *
+     * // Factory pattern (drizzle-kit compatible)
+     * filterFactory: () => create(FilterSchema, { ... loadConfig() ... })
+     * ```
+     */
+    filter?: Filter;
+    /**
+     * Lazy filter factory for drizzle-kit compatibility.
+     * Called once when the indexer starts.
+     */
+    filterFactory?: () => Filter;
+    /**
+     * Parse a raw event into a table row.
+     * Return null to skip the event.
+     *
+     * @param event - Raw event from the chain
+     * @returns Parsed row data or null to skip
+     */
+    parse: (event: Event) => InferRow<TSchema> | null;
+    /** API configuration (used for route generation) */
+    api?: ApiConfig;
+    /**
+     * Filter batch before committing to database.
+     * Use to filter events based on external state (e.g., registered accounts).
+     *
+     * @param events - Parsed events about to be committed
+     * @param ctx - Hook context with database access
+     * @returns Filtered array of events to commit
+     */
+    filterBatch?: (events: InferRow<TSchema>[], ctx: HookContext) => Promise<InferRow<TSchema>[]>;
+    /**
+     * Called after a batch of events is committed to the database.
+     * Use for side effects like notifications, webhooks, analytics.
+     * Errors are logged but do not block indexing.
+     *
+     * @param batch - The committed batch with slot and events
+     * @param ctx - Hook context with database access
+     */
+    onCommit?: (batch: StreamBatch<InferRow<TSchema>>, ctx: HookContext) => Promise<void>;
+}
+/**
+ * A compiled event stream with table and methods.
+ * This is what defineEventStream() returns.
+ */
+interface EventStream<TSchema extends SchemaDefinition = SchemaDefinition> {
+    /** Stream name */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** The schema definition (for validation) */
+    readonly schema: TSchema;
+    /** The Drizzle table for this stream */
+    readonly table: PgTableWithColumns<any>;
+    /**
+     * Typed column accessors for use with Drizzle operators.
+     * Use with eq(), inArray(), etc.
+     *
+     * @example
+     * ```ts
+     * db.select().from(stream.table).where(eq(stream.c.source, address))
+     * ```
+     */
+    readonly c: Columns<TSchema>;
+    /** Get the CEL filter for @thru/replay (resolves lazy factory if used) */
+    getFilter(): Filter;
+    /** Parse function */
+    readonly parse: (event: Event) => InferRow<TSchema> | null;
+    /** API configuration */
+    readonly api?: ApiConfig;
+    /** Filter batch hook */
+    readonly filterBatch?: (events: InferRow<TSchema>[], ctx: HookContext) => Promise<InferRow<TSchema>[]>;
+    /** Post-commit hook */
+    readonly onCommit?: (batch: StreamBatch<InferRow<TSchema>>, ctx: HookContext) => Promise<void>;
+}
+
+/**
+ * Define an event stream for indexing blockchain events.
+ *
+ * Event streams index historical, immutable event data from the chain.
+ * Each event is stored once and never updated.
+ *
+ * @example
+ * ```ts
+ * import { defineEventStream, t } from "@thru/indexer";
+ * import { create } from "@bufbuild/protobuf";
+ * import { FilterSchema, type Event } from "@thru/replay";
+ *
+ * export const transfers = defineEventStream({
+ *   name: "transfers",
+ *
+ *   schema: {
+ *     id: t.text().primaryKey(),
+ *     slot: t.bigint().notNull().index(),
+ *     source: t.text().notNull().index(),
+ *     dest: t.text().notNull().index(),
+ *     amount: t.bigint().notNull(),
+ *   },
+ *
+ *   filter: create(FilterSchema, {
+ *     expression: "event.program.value == params.address",
+ *     params: { address: ... },
+ *   }),
+ *
+ *   parse: (event: Event) => {
+ *     if (!event.payload) return null;
+ *     return {
+ *       id: event.eventId,
+ *       slot: event.slot!,
+ *       source: decodeAddress(event.payload, 0),
+ *       dest: decodeAddress(event.payload, 32),
+ *       amount: decodeBigint(event.payload, 64),
+ *     };
+ *   },
+ *
+ *   api: { filters: ["source", "dest"] },
+ * });
+ *
+ * // Export the table for Drizzle migrations
+ * export const transfersTable = transfers.table;
+ * ```
+ */
+
+/**
+ * Define an event stream for indexing blockchain events.
+ *
+ * @param definition - Stream definition with schema, filter, and parse function
+ * @returns A compiled event stream ready for use with the indexer
+ */
+declare function defineEventStream<TSchema extends SchemaDefinition>(definition: EventStreamDefinition<TSchema>): EventStream<TSchema>;
+
+/**
+ * Event stream processor.
+ *
+ * Processes events from @thru/replay and commits them to the database
+ * with batching and checkpointing.
+ */
+
+interface ProcessorStats {
+    /** Total events processed */
+    eventsProcessed: number;
+    /** Total batches committed */
+    batchesCommitted: number;
+    /** Last slot processed */
+    lastSlot: bigint | null;
+}
+
+/**
+ * Account stream type definitions.
+ */
+
+/**
+ * Definition input for creating an account stream.
+ * This is what users pass to defineAccountStream().
+ */
+interface AccountStreamDefinition<TSchema extends SchemaDefinition> {
+    /** Unique stream name (used for table name, checkpointing) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /**
+     * Owner program address bytes.
+     * Filters accounts by their owner program.
+     *
+     * Use `ownerProgram` for direct values, or `ownerProgramFactory` for lazy loading
+     * (required for drizzle-kit compatibility when config isn't available at import time).
+     */
+    ownerProgram?: Uint8Array;
+    /**
+     * Lazy factory for owner program address.
+     * Called once when the indexer starts.
+     */
+    ownerProgramFactory?: () => Uint8Array;
+    /** Expected account data size (for filtering by account type) */
+    expectedSize?: number;
+    /**
+     * Additional data sizes to accept.
+     * Use when an account type can have multiple valid sizes.
+     */
+    dataSizes?: number[];
+    /**
+     * Schema definition using the column builder.
+     * Defines the structure of the indexed account data.
+     *
+     * @example
+     * ```ts
+     * schema: {
+     *   address: t.text().primaryKey(),
+     *   mint: t.text().notNull().index(),
+     *   owner: t.text().notNull().index(),
+     *   amount: t.bigint().notNull(),
+     *   slot: t.bigint().notNull(),
+     *   seq: t.bigint().notNull(),
+     *   updatedAt: t.timestamp().notNull().defaultNow(),
+     * }
+     * ```
+     */
+    schema: TSchema;
+    /**
+     * Parse account state into a table row.
+     * Return null to skip the account.
+     *
+     * @param account - Account state from the chain
+     * @returns Parsed row data or null to skip
+     */
+    parse: (account: AccountState) => InferRow<TSchema> | null;
+    /** API configuration (used for route generation) */
+    api?: ApiConfig;
+}
+/**
+ * A compiled account stream with table and methods.
+ * This is what defineAccountStream() returns.
+ */
+interface AccountStream<TSchema extends SchemaDefinition = SchemaDefinition> {
+    /** Stream name */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** The schema definition (for validation) */
+    readonly schema: TSchema;
+    /** Get owner program address bytes (resolves lazy factory if used) */
+    getOwnerProgram(): Uint8Array;
+    /** Expected account data size */
+    readonly expectedSize?: number;
+    /** Additional data sizes to accept */
+    readonly dataSizes?: number[];
+    /** The Drizzle table for this stream */
+    readonly table: PgTableWithColumns<any>;
+    /**
+     * Typed column accessors for use with Drizzle operators.
+     * Use with eq(), inArray(), etc.
+     *
+     * @example
+     * ```ts
+     * db.select().from(stream.table).where(eq(stream.c.owner, address))
+     * ```
+     */
+    readonly c: Columns<TSchema>;
+    /** Parse function */
+    readonly parse: (account: AccountState) => InferRow<TSchema> | null;
+    /** API configuration */
+    readonly api?: ApiConfig;
+}
+
+/**
+ * Define an account stream for indexing on-chain account state.
+ *
+ * Account streams track current state of on-chain accounts.
+ * Unlike event streams (historical log), account streams are mutable -
+ * rows are updated when account state changes.
+ *
+ * @example
+ * ```ts
+ * import { defineAccountStream, t } from "@thru/indexer";
+ * import { decodeAddress } from "@thru/helpers";
+ * import type { AccountState } from "@thru/replay";
+ *
+ * export const tokenAccounts = defineAccountStream({
+ *   name: "token-accounts",
+ *
+ *   ownerProgram: decodeAddress(TOKEN_PROGRAM_PUBKEY),
+ *   expectedSize: 73,  // TokenAccount size in bytes
+ *
+ *   schema: {
+ *     address: t.text().primaryKey(),
+ *     mint: t.text().notNull().index(),
+ *     owner: t.text().notNull().index(),
+ *     amount: t.bigint().notNull(),
+ *     isFrozen: t.boolean().notNull(),
+ *     slot: t.bigint().notNull(),
+ *     seq: t.bigint().notNull(),
+ *     updatedAt: t.timestamp().notNull().defaultNow(),
+ *   },
+ *
+ *   parse: (account: AccountState) => {
+ *     if (account.data.length !== 73) return null;
+ *     return {
+ *       address: encodeAddress(account.address),
+ *       mint: parseAddress(account.data, 0),
+ *       owner: parseAddress(account.data, 32),
+ *       amount: parseBigint(account.data, 64),
+ *       isFrozen: account.data[72] !== 0,
+ *       slot: account.slot,
+ *       seq: account.seq,
+ *       updatedAt: new Date(),
+ *     };
+ *   },
+ *
+ *   api: { filters: ["mint", "owner"], idField: "address" },
+ * });
+ *
+ * // Export the table for Drizzle migrations
+ * export const tokenAccountsTable = tokenAccounts.table;
+ * ```
+ */
+
+/**
+ * Define an account stream for indexing on-chain account state.
+ *
+ * @param definition - Stream definition with schema, ownerProgram, and parse function
+ * @returns A compiled account stream ready for use with the indexer
+ */
+declare function defineAccountStream<TSchema extends SchemaDefinition>(definition: AccountStreamDefinition<TSchema>): AccountStream<TSchema>;
+
+/**
+ * Account stream processor.
+ *
+ * Processes account state from @thru/replay and commits to the database
+ * with slot-aware upserts and checkpointing.
+ */
+
+interface AccountProcessorStats {
+    /** Total accounts processed */
+    accountsProcessed: number;
+    /** Total accounts inserted/updated */
+    accountsUpdated: number;
+    /** Total accounts deleted */
+    accountsDeleted: number;
+}
+
+/**
+ * Checkpoint table schema.
+ *
+ * Users should export this from their Drizzle schema for migrations.
+ *
+ * @example
+ * ```ts
+ * // db/schema.ts
+ * import { checkpointTable } from "@thru/indexer";
+ * export { checkpointTable };
+ * ```
+ */
+/**
+ * Per-stream checkpoint table.
+ * Each stream has its own checkpoint keyed by stream name.
+ *
+ * This table should be included in your Drizzle migrations.
+ */
+declare const checkpointTable: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "indexer_checkpoints";
+    schema: undefined;
+    columns: {
+        streamName: drizzle_orm_pg_core.PgColumn<{
+            name: "stream_name";
+            tableName: "indexer_checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastIndexedSlot: drizzle_orm_pg_core.PgColumn<{
+            name: "last_indexed_slot";
+            tableName: "indexer_checkpoints";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastEventId: drizzle_orm_pg_core.PgColumn<{
+            name: "last_event_id";
+            tableName: "indexer_checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "indexer_checkpoints";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Checkpoint data structure.
+ */
+interface Checkpoint {
+    /** Last indexed slot number */
+    slot: bigint;
+    /** Last event ID (for cursor-based resume) */
+    eventId: string | null;
+}
+
+/**
+ * Checkpoint repository for reading and updating stream checkpoints.
+ */
+
+/**
+ * Get the checkpoint for a specific stream.
+ * Returns null if no checkpoint exists yet.
+ *
+ * @param db - Database client
+ * @param streamName - Name of the stream
+ * @returns Checkpoint or null if not found
+ */
+declare function getCheckpoint(db: DatabaseClient, streamName: string): Promise<Checkpoint | null>;
+/**
+ * Update the checkpoint for a specific stream.
+ * Uses upsert to handle both insert and update cases.
+ *
+ * @param db - Database client (can be a transaction)
+ * @param streamName - Name of the stream
+ * @param slot - Last indexed slot number
+ * @param eventId - Last event ID (optional)
+ */
+declare function updateCheckpoint(db: DatabaseClient, streamName: string, slot: bigint, eventId?: string | null): Promise<void>;
+/**
+ * Delete the checkpoint for a specific stream.
+ * Use with caution - this will cause the stream to re-index from the start.
+ *
+ * @param db - Database client
+ * @param streamName - Name of the stream
+ */
+declare function deleteCheckpoint(db: DatabaseClient, streamName: string): Promise<void>;
+/**
+ * Get all checkpoints.
+ * Useful for monitoring and debugging.
+ *
+ * @param db - Database client
+ * @returns Array of checkpoints with stream names
+ */
+declare function getAllCheckpoints(db: DatabaseClient): Promise<Array<{
+    streamName: string;
+    checkpoint: Checkpoint;
+}>>;
+
+/**
+ * Checkpoint module exports.
+ */
+
+/**
+ * Get all tables that need to be exported for Drizzle migrations.
+ *
+ * This helper collects the checkpoint table and all stream tables
+ * into a single object for easy export in your schema file.
+ *
+ * @example
+ * ```ts
+ * // db/schema.ts
+ * import { getSchemaExports } from "@thru/indexer";
+ * import transfers from "../streams/transfers";
+ * import tokenAccounts from "../account-streams/token-accounts";
+ *
+ * export const {
+ *   checkpointTable,
+ *   transfersTable,
+ *   tokenAccountsTable,
+ * } = getSchemaExports({
+ *   eventStreams: [transfers],
+ *   accountStreams: [tokenAccounts],
+ *   tableNames: {
+ *     transfers: "transfersTable",
+ *     "token-accounts": "tokenAccountsTable",
+ *   },
+ * });
+ * ```
+ */
+declare function getSchemaExports(config: {
+    eventStreams?: EventStream<any>[];
+    accountStreams?: AccountStream<any>[];
+    tableNames?: Record<string, string>;
+}): Record<string, PgTableWithColumns<any>>;
+
+/**
+ * Route generation for event and account streams.
+ *
+ * Auto-generates list and get routes with filtering and pagination.
+ */
+
+interface MountRoutesOptions {
+    /** Database client */
+    db: DatabaseClient;
+    /** Event streams to create routes for */
+    eventStreams?: EventStream[];
+    /** Account streams to create routes for */
+    accountStreams?: AccountStream[];
+    /** Path prefix (default: "/api/v1") */
+    pathPrefix?: string;
+}
+/**
+ * Mount auto-generated routes for event and account streams.
+ *
+ * @param app - Hono app to mount routes on
+ * @param options - Configuration options
+ *
+ * @example
+ * ```ts
+ * import { OpenAPIHono } from "@hono/zod-openapi";
+ * import { mountStreamRoutes } from "@thru/indexer";
+ * import { transfers } from "./streams/transfers";
+ * import { tokenAccounts } from "./account-streams/token-accounts";
+ *
+ * const app = new OpenAPIHono();
+ *
+ * mountStreamRoutes(app, {
+ *   db,
+ *   eventStreams: [transfers],
+ *   accountStreams: [tokenAccounts],
+ * });
+ *
+ * // Routes generated:
+ * // GET /api/v1/transfers
+ * // GET /api/v1/transfers/:id
+ * // GET /api/v1/token-accounts
+ * // GET /api/v1/token-accounts/:address
+ * ```
+ */
+declare function mountStreamRoutes(app: OpenAPIHono, options: MountRoutesOptions): void;
+
+/**
+ * Schema generation utilities.
+ *
+ * Generates Zod schemas and serializers from Drizzle tables.
+ */
+
+interface GeneratedSchemas {
+    /** Row schema (database types) */
+    row: z$1.ZodTypeAny;
+    /** Insert schema (validation for inserts) */
+    insert: z$1.ZodTypeAny;
+    /** API output schema (serialized for JSON) */
+    api: z$1.ZodTypeAny;
+    /** Serialize a database row for API output */
+    serialize: (row: Record<string, unknown>) => Record<string, unknown>;
+}
+/**
+ * Generate Zod schemas from a Drizzle table.
+ *
+ * Handles bigint → string and Date → ISO string serialization
+ * for JSON-safe API responses.
+ *
+ * @param table - Drizzle table
+ * @param name - Schema name for OpenAPI
+ * @param suffix - Suffix for OpenAPI schema name (e.g., "Event", "Account")
+ * @returns Generated schemas and serializer
+ */
+declare function generateSchemas(table: PgTableWithColumns<any>, name: string, suffix?: string): GeneratedSchemas;
+
+/**
+ * Pagination utilities for API routes.
+ */
+
+/**
+ * Query parameters for paginated list endpoints.
+ */
+declare const paginationQuerySchema: z$1.ZodObject<{
+    limit: z$1.ZodDefault<z$1.ZodNumber>;
+    offset: z$1.ZodDefault<z$1.ZodNumber>;
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+}, "strip", z$1.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    cursor?: string | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    cursor?: string | undefined;
+}>;
+type PaginationQuery = z$1.infer<typeof paginationQuerySchema>;
+/**
+ * Pagination metadata in responses.
+ */
+declare const paginationResponseSchema: z$1.ZodObject<{
+    limit: z$1.ZodNumber;
+    offset: z$1.ZodNumber;
+    hasMore: z$1.ZodBoolean;
+    nextCursor: z$1.ZodNullable<z$1.ZodString>;
+}, "strip", z$1.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+}, {
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+}>;
+type PaginationResponse = z$1.infer<typeof paginationResponseSchema>;
+/**
+ * Wrap a schema in a data response.
+ */
+declare function dataResponse<T extends z$1.ZodTypeAny>(schema: T): z$1.ZodObject<{
+    data: T;
+}, "strip", z$1.ZodTypeAny, z$1.objectUtil.addQuestionMarks<z$1.baseObjectOutputType<{
+    data: T;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z$1.baseObjectInputType<{
+    data: T;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+/**
+ * Wrap a schema in a list response with pagination.
+ */
+declare function listResponse<T extends z$1.ZodTypeAny>(schema: T): z$1.ZodObject<{
+    data: z$1.ZodArray<T, "many">;
+    pagination: z$1.ZodObject<{
+        limit: z$1.ZodNumber;
+        offset: z$1.ZodNumber;
+        hasMore: z$1.ZodBoolean;
+        nextCursor: z$1.ZodNullable<z$1.ZodString>;
+    }, "strip", z$1.ZodTypeAny, {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }, {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+}, "strip", z$1.ZodTypeAny, {
+    data: T["_output"][];
+    pagination: {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+}, {
+    data: T["_input"][];
+    pagination: {
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+}>;
+/**
+ * Standard error response schema.
+ */
+declare const errorSchema: z$1.ZodObject<{
+    error: z$1.ZodString;
+    code: z$1.ZodOptional<z$1.ZodString>;
+}, "strip", z$1.ZodTypeAny, {
+    error: string;
+    code?: string | undefined;
+}, {
+    error: string;
+    code?: string | undefined;
+}>;
+type ErrorResponse = z$1.infer<typeof errorSchema>;
+interface PaginationResult<T> {
+    data: T[];
+    pagination: PaginationResponse;
+}
+/**
+ * Process raw results into paginated response.
+ * Expects `limit + 1` rows to determine hasMore.
+ *
+ * @param rows - Query results (should have limit + 1 rows)
+ * @param query - The pagination query parameters
+ * @param getCursor - Optional function to get cursor from last item
+ * @returns Paginated result with data and pagination metadata
+ */
+declare function paginate<T>(rows: T[], query: PaginationQuery, getCursor?: (item: T) => string | null): PaginationResult<T>;
+/**
+ * Parse a cursor string into slot and id components.
+ *
+ * @param cursor - Cursor string in format "slot:id"
+ * @returns Parsed cursor or null if invalid
+ */
+declare function parseCursor(cursor: string): {
+    slot: bigint;
+    id: string;
+} | null;
+
+/**
+ * Indexer configuration types.
+ */
+
+/**
+ * Configuration for the Indexer runtime.
+ */
+interface IndexerConfig {
+    /** Database client */
+    db: DatabaseClient;
+    /** Factory to create fresh chain clients for reconnection */
+    clientFactory: ChainClientFactory;
+    /** Event streams to run */
+    eventStreams?: EventStream[];
+    /** Account streams to run */
+    accountStreams?: AccountStream[];
+    /** Default start slot if no checkpoint exists (default: 0n) */
+    defaultStartSlot?: bigint;
+    /** Safety margin for finality in slots (default: 64) */
+    safetyMargin?: number;
+    /** Page size for fetching events (default: 512) */
+    pageSize?: number;
+    /** Log level (default: "info") */
+    logLevel?: "debug" | "info" | "warn" | "error";
+    /**
+     * Validate parse output at runtime using Zod schemas.
+     * Useful for development to catch type mismatches early.
+     * Disabled by default for performance in production.
+     * @default false
+     */
+    validateParse?: boolean;
+}
+
+/**
+ * Indexer runtime class.
+ *
+ * Orchestrates running multiple event and account streams concurrently
+ * with graceful shutdown support.
+ *
+ * @example
+ * ```ts
+ * import { Indexer } from "@thru/indexer";
+ * import { ChainClient } from "@thru/replay";
+ * import { transfers } from "./streams/transfers";
+ * import { tokenAccounts } from "./account-streams/token-accounts";
+ *
+ * const indexer = new Indexer({
+ *   db,
+ *   clientFactory: () => new ChainClient({ baseUrl: RPC_URL }),
+ *   eventStreams: [transfers],
+ *   accountStreams: [tokenAccounts],
+ *   defaultStartSlot: 0n,
+ *   safetyMargin: 64,
+ * });
+ *
+ * // Handle graceful shutdown
+ * process.on("SIGINT", () => indexer.stop());
+ * process.on("SIGTERM", () => indexer.stop());
+ *
+ * // Start indexing
+ * await indexer.start();
+ * ```
+ */
+
+interface IndexerResult {
+    /** Results from event stream processors */
+    eventStreams: Array<{
+        name: string;
+        status: "fulfilled" | "rejected";
+        result?: ProcessorStats;
+        error?: Error;
+    }>;
+    /** Results from account stream processors */
+    accountStreams: Array<{
+        name: string;
+        status: "fulfilled" | "rejected";
+        result?: AccountProcessorStats;
+        error?: Error;
+    }>;
+}
+/**
+ * Indexer runtime that orchestrates event and account streams.
+ */
+declare class Indexer {
+    private config;
+    private abortController;
+    private running;
+    private shutdownRequested;
+    constructor(config: IndexerConfig);
+    /**
+     * Check if the checkpoint table exists in the database.
+     * Logs a warning if it doesn't exist (user may have forgotten to export it in schema).
+     */
+    private checkCheckpointTable;
+    /**
+     * Start the indexer.
+     *
+     * Runs all configured event and account streams concurrently.
+     * Returns when all streams complete or when stop() is called.
+     *
+     * @returns Results from all stream processors
+     */
+    start(): Promise<IndexerResult>;
+    /**
+     * Stop the indexer gracefully.
+     *
+     * Signals all streams to finish their current batch and stop.
+     * The start() promise will resolve once all streams have stopped.
+     */
+    stop(): void;
+    /**
+     * Check if the indexer is currently running.
+     */
+    isRunning(): boolean;
+}
+
+export { type AccountStream, type AccountStreamDefinition, type AnyColumnDef, type ApiConfig, type Checkpoint, type ColumnBuilder, type ColumnDef, type Columns, type DatabaseClient, type ErrorResponse, type EventStream, type EventStreamDefinition, type GeneratedSchemas, type HookContext, Indexer, type IndexerConfig, type IndexerResult, type InferInsert, type InferRow, type MountRoutesOptions, type PaginationQuery, type PaginationResponse, type PaginationResult, type SchemaDefinition, type StreamBatch, checkpointTable, columnBuilder, dataResponse, defineAccountStream, defineEventStream, deleteCheckpoint, errorSchema, generateSchemas, generateZodSchema, getAllCheckpoints, getCheckpoint, getSchemaExports, listResponse, mountStreamRoutes, paginate, paginationQuerySchema, paginationResponseSchema, parseCursor, t, updateCheckpoint, validateParsedData };