@aigne/afs-sqlite 1.1.0-beta.1 → 1.11.0-beta

package/dist/index.d.mts

@@ -0,0 +1,758 @@
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSEntry, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRoot, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import * as zod0 from "zod";
+import { z } from "zod";
+import { RadixRouter } from "radix3";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+
+//#region src/schema/types.d.ts
+/**
+ * Column information from SQLite PRAGMA table_info
+ */
+interface ColumnInfo {
+  /** Column name */
+  name: string;
+  /** SQLite type (INTEGER, TEXT, REAL, BLOB, etc.) */
+  type: string;
+  /** Whether the column has NOT NULL constraint */
+  notnull: boolean;
+  /** Whether this column is part of the primary key */
+  pk: number;
+  /** Default value for the column */
+  dfltValue: unknown;
+}
+/**
+ * Foreign key information from SQLite PRAGMA foreign_key_list
+ */
+interface ForeignKeyInfo {
+  /** Foreign key id */
+  id: number;
+  /** Sequence number for composite foreign keys */
+  seq: number;
+  /** Referenced table */
+  table: string;
+  /** Column in this table */
+  from: string;
+  /** Column in referenced table */
+  to: string;
+  /** ON UPDATE action */
+  onUpdate: string;
+  /** ON DELETE action */
+  onDelete: string;
+  /** MATCH clause */
+  match: string;
+}
+/**
+ * Index information from SQLite PRAGMA index_list
+ */
+interface IndexInfo {
+  /** Index sequence number */
+  seq: number;
+  /** Index name */
+  name: string;
+  /** Whether this is a unique index */
+  unique: boolean;
+  /** Origin of the index (c = CREATE INDEX, u = UNIQUE constraint, pk = PRIMARY KEY) */
+  origin: string;
+  /** Whether the index is partial */
+  partial: boolean;
+}
+/**
+ * Complete schema information for a single table
+ */
+interface TableSchema {
+  /** Table name */
+  name: string;
+  /** Column definitions */
+  columns: ColumnInfo[];
+  /** Primary key column names */
+  primaryKey: string[];
+  /** Foreign key relationships */
+  foreignKeys: ForeignKeyInfo[];
+  /** Indexes on this table */
+  indexes: IndexInfo[];
+}
+/**
+ * Raw PRAGMA table_info result row
+ */
+interface PragmaTableInfoRow {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: unknown;
+  pk: number;
+}
+/**
+ * Raw PRAGMA foreign_key_list result row
+ */
+interface PragmaForeignKeyRow {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+  match: string;
+}
+/**
+ * Raw PRAGMA index_list result row
+ */
+interface PragmaIndexListRow {
+  seq: number;
+  name: string;
+  unique: number;
+  origin: string;
+  partial: number;
+}
+//#endregion
+//#region src/actions/types.d.ts
+/**
+ * Context provided to action handlers
+ */
+interface ActionContext {
+  /** Database instance */
+  db: LibSQLDatabase;
+  /** All table schemas */
+  schemas: Map<string, TableSchema>;
+  /** Table this action is being executed on */
+  table: string;
+  /** Primary key of the row (if row-level action) */
+  pk?: string;
+  /** The row data (if available) */
+  row?: Record<string, unknown>;
+  /** Reference to the parent module for advanced operations */
+  module: {
+    refreshSchema(): Promise<void>;
+    exportTable(table: string, format: string): Promise<unknown>;
+  };
+}
+/**
+ * Action handler function signature
+ */
+type ActionHandler = (ctx: ActionContext, params: Record<string, unknown>) => Promise<ActionResult>;
+/**
+ * Result from an action execution
+ */
+interface ActionResult {
+  success: boolean;
+  data?: unknown;
+  message?: string;
+}
+/**
+ * Action definition with metadata
+ */
+interface ActionDefinition {
+  /** Action name */
+  name: string;
+  /** Description of what the action does */
+  description?: string;
+  /** Whether this action is available at table level (vs row level) */
+  tableLevel?: boolean;
+  /** Whether this action is available at row level */
+  rowLevel?: boolean;
+  /** Input schema for the action parameters */
+  inputSchema?: Record<string, unknown>;
+  /** The handler function */
+  handler: ActionHandler;
+}
+//#endregion
+//#region src/actions/registry.d.ts
+/**
+ * Registry for managing action handlers
+ */
+declare class ActionsRegistry {
+  private handlers;
+  /**
+       * Registers an action handler
+       */
+  register(definition: ActionDefinition): void;
+  /**
+       * Registers a simple action with just name and handler
+       */
+  registerSimple(name: string, handler: ActionHandler, options?: {
+    description?: string;
+    tableLevel?: boolean;
+    rowLevel?: boolean;
+  }): void;
+  /**
+       * Unregisters an action
+       */
+  unregister(name: string): boolean;
+  /**
+       * Checks if an action is registered
+       */
+  has(name: string): boolean;
+  /**
+       * Gets an action definition
+       */
+  get(name: string): ActionDefinition | undefined;
+  /**
+       * Lists all registered actions
+       */
+  list(options?: {
+    tableLevel?: boolean;
+    rowLevel?: boolean;
+  }): ActionDefinition[];
+  /**
+       * Lists action names
+       */
+  listNames(options?: {
+    tableLevel?: boolean;
+    rowLevel?: boolean;
+  }): string[];
+  /**
+       * Executes an action
+       */
+  execute(name: string, ctx: ActionContext, params?: Record<string, unknown>): Promise<ActionResult>;
+}
+//#endregion
+//#region src/actions/built-in.d.ts
+/**
+ * Registers built-in actions to the registry
+ */
+declare function registerBuiltInActions(registry: ActionsRegistry): void;
+//#endregion
+//#region src/config.d.ts
+/**
+ * SQLite AFS module configuration schema
+ */
+declare const sqliteAFSConfigSchema: z.ZodObject<{
+  url: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  accessMode: z.ZodOptional<z.ZodEnum<["readonly", "readwrite"]>>;
+  tables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  excludeTables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  fts: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    tables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+  }, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    tables?: Record<string, string[]> | undefined;
+  }, {
+    tables?: Record<string, string[]> | undefined;
+    enabled?: boolean | undefined;
+  }>>;
+  wal: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+  url: string;
+  wal: boolean;
+  name?: string | undefined;
+  description?: string | undefined;
+  accessMode?: "readonly" | "readwrite" | undefined;
+  tables?: string[] | undefined;
+  excludeTables?: string[] | undefined;
+  fts?: {
+    enabled: boolean;
+    tables?: Record<string, string[]> | undefined;
+  } | undefined;
+}, {
+  url: string;
+  name?: string | undefined;
+  description?: string | undefined;
+  accessMode?: "readonly" | "readwrite" | undefined;
+  tables?: string[] | undefined;
+  excludeTables?: string[] | undefined;
+  fts?: {
+    tables?: Record<string, string[]> | undefined;
+    enabled?: boolean | undefined;
+  } | undefined;
+  wal?: boolean | undefined;
+}>;
+/**
+ * SQLite AFS module configuration type
+ */
+type SQLiteAFSConfig = z.infer<typeof sqliteAFSConfigSchema>;
+/**
+ * SQLite AFS module options (after parsing)
+ */
+interface SQLiteAFSOptions {
+  /** SQLite database URL */
+  url: string;
+  /** Module name */
+  name?: string;
+  /** Module description */
+  description?: string;
+  /** Access mode */
+  accessMode?: AFSAccessMode;
+  /** Tables to expose */
+  tables?: string[];
+  /** Tables to exclude */
+  excludeTables?: string[];
+  /** FTS configuration */
+  fts?: {
+    enabled?: boolean;
+    tables?: Record<string, string[]>;
+  };
+  /** Enable WAL mode */
+  wal?: boolean;
+}
+//#endregion
+//#region src/node/builder.d.ts
+/**
+ * Options for building an AFSEntry
+ */
+interface BuildEntryOptions {
+  /** Base path prefix (e.g., empty string or module mount path) */
+  basePath?: string;
+}
+/**
+ * Builds an AFSEntry from a database row
+ */
+declare function buildRowEntry(table: string, schema: TableSchema, row: Record<string, unknown>, options?: BuildEntryOptions): AFSEntry;
+/**
+ * Builds an AFSEntry for a table listing
+ */
+declare function buildTableEntry(table: string, schema: TableSchema, options?: BuildEntryOptions & {
+  rowCount?: number;
+}): AFSEntry;
+/**
+ * Builds an AFSEntry for table schema
+ */
+declare function buildSchemaEntry(table: string, schema: TableSchema, options?: BuildEntryOptions): AFSEntry;
+/**
+ * Builds an AFSEntry for an attribute (single column value)
+ */
+declare function buildAttributeEntry(table: string, pk: string, column: string, value: unknown, options?: BuildEntryOptions): AFSEntry;
+/**
+ * Builds an AFSEntry listing all attributes for a row
+ */
+declare function buildAttributeListEntry(table: string, schema: TableSchema, pk: string, row: Record<string, unknown>, options?: BuildEntryOptions): AFSEntry[];
+/**
+ * Builds an AFSEntry for row metadata
+ */
+declare function buildMetaEntry(table: string, schema: TableSchema, pk: string, row: Record<string, unknown>, options?: BuildEntryOptions): AFSEntry;
+/**
+ * Builds AFSEntry for actions list
+ */
+declare function buildActionsListEntry(table: string, pk: string, actions: string[], options?: BuildEntryOptions): AFSEntry[];
+/**
+ * Builds a search result entry with highlights
+ */
+declare function buildSearchEntry(table: string, schema: TableSchema, row: Record<string, unknown>, snippet?: string, options?: BuildEntryOptions): AFSEntry;
+//#endregion
+//#region src/operations/crud.d.ts
+/**
+ * CRUD operations for SQLite AFS
+ */
+declare class CRUDOperations {
+  private db;
+  private schemas;
+  private basePath;
+  constructor(db: LibSQLDatabase, schemas: Map<string, TableSchema>, basePath?: string);
+  /**
+       * Lists all tables
+       */
+  listTables(): Promise<AFSListResult>;
+  /**
+       * Lists rows in a table
+       */
+  listTable(table: string, options?: AFSListOptions): Promise<AFSListResult>;
+  /**
+       * Reads a single row by primary key
+       */
+  readRow(table: string, pk: string): Promise<AFSReadResult>;
+  /**
+       * Gets table schema
+       */
+  getSchema(table: string): AFSReadResult;
+  /**
+       * Lists attributes (columns) for a row
+       */
+  listAttributes(table: string, pk: string): Promise<AFSListResult>;
+  /**
+       * Gets a single attribute (column value) for a row
+       */
+  getAttribute(table: string, pk: string, column: string): Promise<AFSReadResult>;
+  /**
+       * Gets row metadata
+       */
+  getMeta(table: string, pk: string): Promise<AFSReadResult>;
+  /**
+       * Creates a new row in a table
+       */
+  createRow(table: string, content: Record<string, unknown>): Promise<AFSWriteResult>;
+  /**
+       * Updates an existing row
+       */
+  updateRow(table: string, pk: string, content: Record<string, unknown>): Promise<AFSWriteResult>;
+  /**
+       * Deletes a row by primary key
+       */
+  deleteRow(table: string, pk: string): Promise<AFSDeleteResult>;
+  /**
+       * Checks if a table exists
+       */
+  hasTable(table: string): boolean;
+  /**
+       * Gets the schema for a table
+       */
+  getTableSchema(table: string): TableSchema | undefined;
+  /**
+       * Updates the schemas map (after refresh)
+       */
+  setSchemas(schemas: Map<string, TableSchema>): void;
+}
+//#endregion
+//#region src/operations/query-builder.d.ts
+/**
+ * Builds a SELECT query string for a single row by primary key
+ */
+declare function buildSelectByPK(tableName: string, schema: TableSchema, pk: string): string;
+/**
+ * Builds a SELECT query string for listing rows with optional limit and offset
+ */
+declare function buildSelectAll(tableName: string, options?: {
+  limit?: number;
+  offset?: number;
+  orderBy?: [string, "asc" | "desc"][];
+}): string;
+/**
+ * Builds an INSERT query string from content object
+ */
+declare function buildInsert(tableName: string, schema: TableSchema, content: Record<string, unknown>): string;
+/**
+ * Builds an UPDATE query string from content object
+ */
+declare function buildUpdate(tableName: string, schema: TableSchema, pk: string, content: Record<string, unknown>): string;
+/**
+ * Builds a DELETE query string by primary key
+ */
+declare function buildDelete(tableName: string, schema: TableSchema, pk: string): string;
+/**
+ * Gets the last inserted rowid query string
+ */
+declare function buildGetLastRowId(): string;
+//#endregion
+//#region src/operations/search.d.ts
+/**
+ * FTS5 search configuration for a table
+ */
+interface FTSTableConfig {
+  /** Columns to include in FTS index */
+  columns: string[];
+  /** Whether FTS table has been created */
+  initialized?: boolean;
+}
+/**
+ * FTS5 search configuration
+ */
+interface FTSConfig {
+  /** Whether FTS is enabled */
+  enabled: boolean;
+  /** Per-table FTS configuration */
+  tables: Map<string, FTSTableConfig>;
+}
+/**
+ * FTS5 Search operations for SQLite AFS
+ */
+declare class FTSSearch {
+  private db;
+  private schemas;
+  private config;
+  private basePath;
+  constructor(db: LibSQLDatabase, schemas: Map<string, TableSchema>, config: FTSConfig, basePath?: string);
+  /**
+       * Performs full-text search across configured tables
+       */
+  search(query: string, options?: AFSSearchOptions & {
+    /** Specific tables to search (defaults to all FTS-enabled tables) */tables?: string[];
+  }): Promise<AFSSearchResult>;
+  /**
+       * Searches within a specific table
+       */
+  searchTable(tableName: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Checks if FTS is configured for a table
+       */
+  hasFTS(tableName: string): boolean;
+  /**
+       * Gets FTS configuration for a table
+       */
+  getFTSConfig(tableName: string): FTSTableConfig | undefined;
+  /**
+       * Checks if an FTS table exists
+       */
+  private ftsTableExists;
+  /**
+       * Prepares a query string for FTS5
+       * Handles special characters and case sensitivity
+       */
+  private prepareFTSQuery;
+  /**
+       * Updates the schemas map (after refresh)
+       */
+  setSchemas(schemas: Map<string, TableSchema>): void;
+  /**
+       * Simple search fallback when FTS is not available
+       * Uses LIKE queries on specified columns
+       */
+  simpleLikeSearch(tableName: string, query: string, columns: string[], options?: AFSSearchOptions): Promise<AFSSearchResult>;
+}
+/**
+ * Creates FTS configuration from options
+ */
+declare function createFTSConfig(options?: {
+  enabled?: boolean;
+  tables?: Record<string, string[]>;
+}): FTSConfig;
+//#endregion
+//#region src/router/types.d.ts
+/**
+ * Route action types for SQLite AFS
+ */
+type RouteAction = "listTables" | "listTable" | "readRow" | "createRow" | "getSchema" | "listAttributes" | "getAttribute" | "getMeta" | "listActions" | "executeAction";
+/**
+ * Route data associated with each path pattern
+ */
+interface RouteData {
+  /** The action to perform for this route */
+  action: RouteAction;
+}
+/**
+ * Route match result with params
+ */
+interface RouteMatch extends RouteData {
+  params: RouteParams;
+}
+/**
+ * Dynamic route parameters extracted from path
+ */
+interface RouteParams {
+  /** Table name */
+  table?: string;
+  /** Primary key value */
+  pk?: string;
+  /** Column name for attribute access */
+  column?: string;
+  /** Action name for @actions */
+  action?: string;
+}
+//#endregion
+//#region src/router/path-router.d.ts
+/**
+ * Creates a radix3 router for SQLite AFS path routing
+ *
+ * Routes:
+ * - / → listTables
+ * - /:table → listTable
+ * - /:table/new → createRow
+ * - /:table/@schema → getSchema
+ * - /:table/:pk → readRow
+ * - /:table/:pk/@attr → listAttributes
+ * - /:table/:pk/@attr/:column → getAttribute
+ * - /:table/:pk/@meta → getMeta
+ * - /:table/:pk/@actions → listActions
+ * - /:table/:pk/@actions/:action → executeAction
+ */
+declare function createPathRouter(): RadixRouter<RouteData>;
+/**
+ * Parses a path and returns the matched route with params
+ * @param router - The radix3 router instance
+ * @param path - The path to match
+ * @returns RouteMatch if matched, undefined otherwise
+ */
+declare function matchPath(router: RadixRouter<RouteData>, path: string): RouteMatch | undefined;
+/**
+ * Builds a path from components
+ */
+declare function buildPath(table?: string, pk?: string, suffix?: string): string;
+/**
+ * Checks if a path segment is a virtual path (@attr, @meta, @actions, @schema)
+ */
+declare function isVirtualPath(segment: string): boolean;
+/**
+ * Gets the type of virtual path
+ */
+declare function getVirtualPathType(segment: string): "attr" | "meta" | "actions" | "schema" | null;
+//#endregion
+//#region src/schema/introspector.d.ts
+/**
+ * Schema introspector that uses SQLite PRAGMA queries to discover database schema
+ */
+declare class SchemaIntrospector {
+  /**
+       * Introspects all tables in the database
+       * @param db - Drizzle database instance
+       * @param options - Introspection options
+       * @returns Map of table name to TableSchema
+       */
+  introspect(db: LibSQLDatabase, options?: {
+    /** Whitelist of tables to include */tables?: string[]; /** Tables to exclude */
+    excludeTables?: string[];
+  }): Promise<Map<string, TableSchema>>;
+  /**
+       * Introspects a single table
+       * @param db - Drizzle database instance
+       * @param tableName - Name of the table to introspect
+       * @returns TableSchema for the specified table
+       */
+  introspectTable(db: LibSQLDatabase, tableName: string): Promise<TableSchema>;
+  /**
+       * Gets the primary key column name for a table
+       * Returns the first PK column, or 'rowid' if no explicit PK
+       */
+  getPrimaryKeyColumn(schema: TableSchema): string;
+  /**
+       * Checks if a table has FTS (Full-Text Search) enabled
+       */
+  hasFTS(db: LibSQLDatabase, tableName: string): Promise<boolean>;
+  /**
+       * Creates FTS5 table for full-text search on specified columns
+       */
+  createFTS(db: LibSQLDatabase, tableName: string, columns: string[], options?: {
+    /** Content table (defaults to tableName) */contentTable?: string; /** Content rowid column (defaults to 'rowid') */
+    contentRowid?: string;
+  }): Promise<void>;
+  /**
+       * Rebuilds FTS index for a table (useful after bulk inserts)
+       */
+  rebuildFTS(db: LibSQLDatabase, tableName: string): Promise<void>;
+}
+//#endregion
+//#region src/sqlite-afs.d.ts
+/**
+ * SQLite AFS Module
+ *
+ * Exposes SQLite databases as AFS nodes with full CRUD support,
+ * schema introspection, FTS5 search, and virtual paths (@attr, @meta, @actions).
+ */
+declare class SQLiteAFS implements AFSModule {
+  private options;
+  readonly name: string;
+  readonly description: string;
+  readonly accessMode: AFSAccessMode;
+  private db;
+  private schemas;
+  private router;
+  private crud;
+  private ftsSearch;
+  private actions;
+  private ftsConfig;
+  private initialized;
+  constructor(options: SQLiteAFSOptions);
+  /**
+       * Returns the Zod schema for configuration validation
+       */
+  static schema(): zod0.ZodObject<{
+    url: zod0.ZodString;
+    name: zod0.ZodOptional<zod0.ZodString>;
+    description: zod0.ZodOptional<zod0.ZodString>;
+    accessMode: zod0.ZodOptional<zod0.ZodEnum<["readonly", "readwrite"]>>;
+    tables: zod0.ZodOptional<zod0.ZodArray<zod0.ZodString, "many">>;
+    excludeTables: zod0.ZodOptional<zod0.ZodArray<zod0.ZodString, "many">>;
+    fts: zod0.ZodOptional<zod0.ZodObject<{
+      enabled: zod0.ZodDefault<zod0.ZodBoolean>;
+      tables: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString, "many">>>;
+    }, "strip", zod0.ZodTypeAny, {
+      enabled: boolean;
+      tables?: Record<string, string[]> | undefined;
+    }, {
+      tables?: Record<string, string[]> | undefined;
+      enabled?: boolean | undefined;
+    }>>;
+    wal: zod0.ZodDefault<zod0.ZodOptional<zod0.ZodBoolean>>;
+  }, "strip", zod0.ZodTypeAny, {
+    url: string;
+    wal: boolean;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    tables?: string[] | undefined;
+    excludeTables?: string[] | undefined;
+    fts?: {
+      enabled: boolean;
+      tables?: Record<string, string[]> | undefined;
+    } | undefined;
+  }, {
+    url: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    tables?: string[] | undefined;
+    excludeTables?: string[] | undefined;
+    fts?: {
+      tables?: Record<string, string[]> | undefined;
+      enabled?: boolean | undefined;
+    } | undefined;
+    wal?: boolean | undefined;
+  }>;
+  /**
+       * Loads a module instance from configuration
+       */
+  static load({
+    parsed
+  }: AFSModuleLoadParams): Promise<SQLiteAFS>;
+  /**
+       * Called when the module is mounted to AFS
+       */
+  onMount(_afs: AFSRoot): Promise<void>;
+  /**
+       * Initializes the database connection and introspects schema
+       */
+  private initialize;
+  /**
+       * Ensures the module is initialized
+       */
+  private ensureInitialized;
+  /**
+       * Lists entries at a path
+       */
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  /**
+       * Reads an entry at a path
+       */
+  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+  /**
+       * Writes an entry at a path
+       */
+  write(path: string, content: AFSWriteEntryPayload, _options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  /**
+       * Deletes an entry at a path
+       */
+  delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  /**
+       * Searches for entries matching a query
+       */
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Executes a module operation
+       */
+  exec(path: string, args: Record<string, unknown>, _options: AFSExecOptions): Promise<AFSExecResult>;
+  /**
+       * Lists available actions for a row
+       */
+  private listActions;
+  /**
+       * Executes an action
+       */
+  private executeAction;
+  /**
+       * Refreshes the schema cache
+       */
+  refreshSchema(): Promise<void>;
+  /**
+       * Exports table data in specified format
+       */
+  exportTable(table: string, format: string): Promise<unknown>;
+  /**
+       * Registers a custom action
+       */
+  registerAction(name: string, handler: (ctx: ActionContext, params: Record<string, unknown>) => Promise<unknown>, options?: {
+    description?: string;
+    tableLevel?: boolean;
+    rowLevel?: boolean;
+  }): void;
+  /**
+       * Gets table schemas (for external access)
+       */
+  getSchemas(): Map<string, TableSchema>;
+  /**
+       * Gets the database instance (for advanced operations)
+       */
+  getDatabase(): LibSQLDatabase;
+}
+//#endregion
+export { type ActionContext, type ActionDefinition, type ActionHandler, type ActionResult, ActionsRegistry, type BuildEntryOptions, CRUDOperations, type ColumnInfo, type FTSConfig, FTSSearch, type FTSTableConfig, type ForeignKeyInfo, type IndexInfo, type PragmaForeignKeyRow, type PragmaIndexListRow, type PragmaTableInfoRow, type RouteAction, type RouteData, type RouteMatch, type RouteParams, SQLiteAFS, type SQLiteAFSConfig, type SQLiteAFSOptions, SchemaIntrospector, type TableSchema, buildActionsListEntry, buildAttributeEntry, buildAttributeListEntry, buildDelete, buildGetLastRowId, buildInsert, buildMetaEntry, buildPath, buildRowEntry, buildSchemaEntry, buildSearchEntry, buildSelectAll, buildSelectByPK, buildTableEntry, buildUpdate, createFTSConfig, createPathRouter, getVirtualPathType, isVirtualPath, matchPath, registerBuiltInActions, sqliteAFSConfigSchema };
+//# sourceMappingURL=index.d.mts.map