weifuwu 0.25.2 → 0.27.0

package/dist/opencode/tools/read.d.ts

@@ -1,16 +0,0 @@
-import type { ToolContext } from './index.ts';
-export declare function createReadTool(ctx: ToolContext): import("ai").Tool<{
-    path: string;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}, {
-    error: string;
-    content: null;
-    totalLines: number;
-    linesReturned?: undefined;
-} | {
-    content: string;
-    totalLines: number;
-    linesReturned: number;
-    error?: undefined;
-}>;

package/dist/opencode/tools/skill.d.ts

@@ -1,18 +0,0 @@
-import type { ToolContext } from './index.ts';
-export declare function createSkillTool(ctx: ToolContext): import("ai").Tool<{
-    name: string;
-}, {
-    error: string;
-    name?: undefined;
-    description?: undefined;
-    content?: undefined;
-    license?: undefined;
-    compatibility?: undefined;
-} | {
-    name: string;
-    description: string;
-    content: string;
-    license: string | null;
-    compatibility: string | null;
-    error?: undefined;
-}>;

package/dist/opencode/tools/web.d.ts

@@ -1,18 +0,0 @@
-import type { ToolContext } from './index.ts';
-export declare function createWebTool(_ctx: ToolContext): import("ai").Tool<{
-    url: string;
-}, {
-    content: string;
-    url: string;
-    contentType: string;
-    truncated: boolean;
-    status: number;
-    error?: undefined;
-} | {
-    error: any;
-    url: string;
-    content: null;
-    contentType?: undefined;
-    truncated?: undefined;
-    status?: undefined;
-}>;

package/dist/opencode/tools/write.d.ts

@@ -1,13 +0,0 @@
-import type { ToolContext } from './index.ts';
-export declare function createWriteTool(ctx: ToolContext): import("ai").Tool<{
-    path: string;
-    content: string;
-}, {
-    error: string;
-    path?: undefined;
-    size?: undefined;
-} | {
-    path: string;
-    size: number;
-    error?: undefined;
-}>;

package/dist/opencode/types.d.ts

@@ -1,90 +0,0 @@
-import type { Router } from '../router.ts';
-import type { PostgresClient } from '../postgres/types.ts';
-import type { Closeable } from '../types.ts';
-export interface Session {
-    id: string;
-    tenant_id: string | null;
-    user_id: number;
-    title: string | null;
-    agent_type: string;
-    model: string;
-    system_prompt: string | null;
-    workspace: string | null;
-    metadata: Record<string, unknown>;
-    active: boolean;
-    created_at: string;
-    updated_at: string;
-}
-export interface Message {
-    id: number;
-    session_id: string;
-    role: 'user' | 'assistant' | 'tool';
-    content: string | null;
-    tool_calls: unknown[] | null;
-    tool_results: unknown[] | null;
-    tokens_in: number;
-    tokens_out: number;
-    created_at: string;
-}
-export interface SkillDef {
-    name: string;
-    description: string;
-    content: string;
-    license?: string;
-    compatibility?: string;
-    path?: string;
-}
-export interface SkillRegistry {
-    all: SkillDef[];
-    get(name: string): SkillDef | undefined;
-    list(): SkillDef[];
-}
-export interface ToolPermission {
-    allow: boolean;
-    timeout?: number;
-    maxSize?: number;
-}
-export interface OpencodePermissions {
-    bash?: ToolPermission & {
-        allowPaths?: string[];
-        denyPaths?: string[];
-    };
-    read?: ToolPermission & {
-        denyPaths?: string[];
-    };
-    write?: ToolPermission & {
-        denyPaths?: string[];
-    };
-    edit?: ToolPermission & {
-        denyPaths?: string[];
-    };
-    grep?: ToolPermission & {
-        allowPaths?: string[];
-    };
-    glob?: ToolPermission;
-    web?: ToolPermission;
-    skill?: Record<string, ToolPermission>;
-}
-export interface OpencodeOptions {
-    pg: PostgresClient;
-    model?: string;
-    baseURL?: string;
-    apiKey?: string;
-    workspace?: string;
-    systemPrompt?: string;
-    skills?: SkillDef[];
-    permissions?: OpencodePermissions;
-}
-export interface OpencodeModule extends Router, Closeable {
-    migrate: () => Promise<void>;
-    wsHandler: () => any;
-    close: () => Promise<void>;
-}
-export interface WsClientInfo {
-    sessionId?: string;
-    abortController?: AbortController;
-}
-export interface PendingQuestion {
-    resolve: (answer: string) => void;
-    reject: (err: Error) => void;
-}

package/dist/opencode/ws.d.ts

@@ -1,21 +0,0 @@
-import type { WebSocket, SqlClient } from '../vendor.ts';
-import type { LanguageModel } from 'ai';
-import type { Context } from '../types.ts';
-import type { PendingQuestion, SkillDef, SkillRegistry, OpencodePermissions } from './types.ts';
-interface WsDeps {
-    sql: SqlClient;
-    model: LanguageModel;
-    workspace: string;
-    systemPrompt?: string;
-    skills: SkillDef[];
-    skillsRegistry: SkillRegistry;
-    permissions?: OpencodePermissions;
-    pendingQuestions: Map<string, PendingQuestion>;
-}
-export declare function createWSHandler(deps: WsDeps): {
-    open(ws: WebSocket, ctx: Context): void;
-    message(ws: WebSocket, ctx: Context, data: string | Buffer): Promise<void>;
-    close(ws: WebSocket): void;
-    error(ws: WebSocket, _ctx: Context, _err: Error): void;
-};
-export {};

package/dist/permissions.d.ts

@@ -1,51 +0,0 @@
-import type { SqlClient } from './vendor.ts';
-import type { Middleware, Context, Handler } from './types.ts';
-declare module './types.ts' {
-    interface Context {
-        permissions: {
-            roles: Set<string>;
-            permissions: Set<string>;
-        };
-    }
-}
-export interface PermissionsOptions {
-    /** PostgreSQL client. */
-    pg: {
-        sql: SqlClient;
-    };
-    /** Table prefix (default: '' → _roles, _user_roles, _role_permissions). */
-    prefix?: string;
-}
-export interface PermissionsModule extends Middleware {
-    /**
-     * Middleware that injects `ctx.permissions = { roles, permissions }`.
-     * Reads `ctx.user.id` to look up role assignments.
-     * Must be placed after a middleware that sets `ctx.user`.
-     */
-    (req: Request, ctx: Context, next: Handler): Response | Promise<Response>;
-    /** Assign a role to a user. Creates the role if it doesn't exist. */
-    assignRole(userId: number, role: string): Promise<void>;
-    /** Remove a role from a user. */
-    removeRole(userId: number, role: string): Promise<void>;
-    /** Grant a permission to a role. Creates the role if it doesn't exist. */
-    grantPermission(role: string, permission: string): Promise<void>;
-    /** Revoke a permission from a role. */
-    revokePermission(role: string, permission: string): Promise<void>;
-    /** Get all roles assigned to a user. */
-    getUserRoles(userId: number): Promise<string[]>;
-    /** Get all permissions for a user (union of all role permissions). */
-    getUserPermissions(userId: number): Promise<string[]>;
-    /**
-     * Middleware that rejects the request if the user does not have any of the specified roles.
-     * Must be placed after `permissions()` middleware (which injects ctx.permissions.roles).
-     */
-    requireRole(...roles: string[]): Middleware<Context, Context>;
-    /**
-     * Middleware that rejects the request if the user does not have all specified permissions.
-     * Must be placed after `permissions()` middleware (which injects ctx.permissions.permissions).
-     */
-    requirePermission(...permissions: string[]): Middleware<Context, Context>;
-    /** Create the underlying tables. Safe to call multiple times. */
-    migrate(): Promise<void>;
-}
-export declare function permissions(options: PermissionsOptions): PermissionsModule;

package/dist/postgres/client.d.ts

@@ -1,4 +0,0 @@
-import type { PostgresOptions, PostgresClient } from './types.ts';
-/** Migration tracking table name. Created automatically on first migrate(). */
-export declare const MIGRATIONS_TABLE = "_weifuwu_migrations";
-export declare function postgres(opts?: string | PostgresOptions): PostgresClient;

package/dist/postgres/index.d.ts

@@ -1,4 +0,0 @@
-export { postgres, MIGRATIONS_TABLE } from './client.ts';
-export { PgModule } from './module.ts';
-export type { PostgresOptions, PostgresClient, PostgresInjected } from './types.ts';
-export * from './schema/index.ts';

package/dist/postgres/module.d.ts

@@ -1,17 +0,0 @@
-import type { PostgresClient } from './types.ts';
-import type { SqlClient } from '../vendor.ts';
-import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
-import type { Closeable } from '../types.ts';
-export declare class PgModule implements Closeable {
-    protected sql: SqlClient;
-    protected pg: PostgresClient;
-    constructor(pg: PostgresClient);
-    table<R extends Record<string, unknown>>(tableOrSchema: string | Table<R>, builders?: {
-        [K in keyof R]: ColumnBuilder<R[K]>;
-    }): BoundTable<R>;
-    transaction<T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
-        maxRetries?: number;
-    }): Promise<T>;
-    migrate(): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/postgres/schema/columns.d.ts

@@ -1,99 +0,0 @@
-import { SQL } from './sql.ts';
-/** Reference to another table's column (foreign key). */
-export interface ColumnReference {
-    /** Referenced table name. */
-    table: string;
-    /** Referenced column name (default: `'id'`). */
-    column: string;
-    /** `ON DELETE` action (e.g. `'cascade'`, `'set null'`). */
-    onDelete?: string;
-}
-/**
- * Fluent column builder for DDL generation.
- *
- * ```ts
- * text('name').notNull().unique()
- * integer('user_id').references('users')
- * timestamptz('created_at').default(sql`NOW()`)
- * ```
- */
-export declare class ColumnBuilder<T> {
-    /** Column name. */
-    name: string;
-    /** SQL type string (e.g. `'TEXT'`, `'INTEGER'`). */
-    sqlType: string;
-    /** Whether this column is PRIMARY KEY. */
-    isPrimaryKey: boolean;
-    /** Whether this column allows NULL. */
-    isNullable: boolean;
-    /** Whether this column has a UNIQUE constraint. */
-    isUnique: boolean;
-    /** Whether the value is auto-generated (e.g. SERIAL, UUID defaults). */
-    isAutoGenerate: boolean;
-    /** DEFAULT expression as a raw SQL string. */
-    defaultExpr: string | null;
-    /** Foreign key reference, if any. */
-    ref: ColumnReference | null;
-    constructor(name: string, sqlType: string);
-    /** Mark as PRIMARY KEY (implies NOT NULL). */
-    primaryKey(): this;
-    /** Add NOT NULL constraint. */
-    notNull(): this;
-    /** Allow NULL values (default). */
-    nullable(): this;
-    /** Set a DEFAULT value. Accepts raw SQL, string, number, or boolean. */
-    default(expr: SQL | string | number | boolean): this;
-    /** Add UNIQUE constraint. */
-    unique(): this;
-    /** Add FOREIGN KEY reference to another table. */
-    references(table: string, column?: string, onDelete?: string): this;
-}
-/** Auto-incrementing integer primary key (`SERIAL`). */
-export declare function serial(name: string): ColumnBuilder<number>;
-/** UUID column. */
-export declare function uuid(name: string): ColumnBuilder<string>;
-/** TEXT column. */
-export declare function text(name: string): ColumnBuilder<string>;
-/** INTEGER column. */
-export declare function integer(name: string): ColumnBuilder<number>;
-/** BOOLEAN column (exported as `boolean`). */
-export declare function boolean_(name: string): ColumnBuilder<boolean>;
-export { boolean_ as boolean };
-/** TIMESTAMPTZ column (timestamp with time zone). */
-export declare function timestamptz(name: string): ColumnBuilder<string>;
-/** JSONB column (stores arbitrary JSON data). */
-export declare function jsonb<T = unknown>(name: string): ColumnBuilder<T>;
-/** TEXT[] column (PostgreSQL array of text). */
-export declare function textArray(name: string): ColumnBuilder<string[]>;
-/** Vector column for pgvector (embedding storage). Requires `dimensions`. */
-export declare function vector(name: string, dims: number): ColumnBuilder<number[]>;
-export interface PartitionByDef {
-    type: 'RANGE' | 'LIST' | 'HASH';
-    column: string;
-}
-export declare function partitionBy(type: 'range' | 'list' | 'hash', column: string): PartitionByDef;
-/**
- * Create a pair of `created_at` / `updated_at` timestamp columns
- * that default to `NOW()` and are NOT NULL.
- *
- * ```ts
- * pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name'),
- *   ...timestamps(),
- * })
- * ```
- */
-export declare function timestamps(): {
-    readonly created_at: ColumnBuilder<string>;
-    readonly updated_at: ColumnBuilder<string>;
-};
-/**
- * Convert a ColumnBuilder into a DDL column definition string.
- *
- * ```ts
- * toDDL(text('name').notNull())
- * // '"name" TEXT NOT NULL'
- * ```
- */
-export declare function toDDL(col: ColumnBuilder<unknown>): string;

package/dist/postgres/schema/index.d.ts

@@ -1,6 +0,0 @@
-export { sql, SQL } from './sql.ts';
-export { ColumnBuilder, serial, uuid, text, integer, boolean as boolean, boolean_, timestamptz, jsonb, textArray, vector, toDDL, partitionBy, timestamps, } from './columns.ts';
-export type { PartitionByDef } from './columns.ts';
-export { pgTable, Table, BoundTable } from './table.ts';
-export type { IndexOptions, FindOptions, CreateOptions } from './table.ts';
-export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not, } from './where.ts';

package/dist/postgres/schema/sql.d.ts

@@ -1,22 +0,0 @@
-/**
- * A parameterized SQL fragment with template strings and bound values.
- * Used internally by the schema builder and where helpers.
- */
-export declare class SQL {
-    /** Template string parts (interleaved with values). */
-    strings: TemplateStringsArray;
-    /** Bound parameter values. */
-    values: unknown[];
-    constructor(strings: TemplateStringsArray, values: unknown[]);
-    /** Serialize to a raw SQL string (interpolating values inline for DDL use). */
-    toSQL(): string;
-}
-/**
- * Tagged template helper for creating parameterized SQL fragments.
- *
- * ```ts
- * sql`NOW()`
- * sql`${column} ILIKE ${'%' + search + '%'}`
- * ```
- */
-export declare function sql(strings: TemplateStringsArray, ...values: unknown[]): SQL;

package/dist/postgres/schema/table.d.ts

@@ -1,141 +0,0 @@
-import type { SqlClient } from '../../vendor.ts';
-import { ColumnBuilder, type PartitionByDef } from './columns.ts';
-import { SQL } from './sql.ts';
-/** Options for table index creation. */
-export interface IndexOptions {
-    /** Whether the index should be UNIQUE. */
-    unique?: boolean;
-    /** Index type: btree (default), hnsw (pgvector), gin (JSONB). */
-    type?: 'btree' | 'hnsw' | 'gin';
-    /** Create index in DESC order. */
-    desc?: boolean;
-    /** Custom operator class (e.g. `vector_cosine_ops`). */
-    operator?: string;
-}
-/** Options for CREATE TABLE. */
-export interface CreateOptions {
-    /** Partition by clause (RANGE, LIST, or HASH). */
-    partitionBy?: PartitionByDef;
-}
-/** Options for find/read queries. */
-export interface FindOptions {
-    /** ORDER BY clause: `{ column: 'asc' | 'desc' }`. */
-    orderBy?: Record<string, 'asc' | 'desc'>;
-    /** LIMIT. */
-    limit?: number;
-    /** OFFSET. */
-    offset?: number;
-    /** Columns to SELECT (default: all). */
-    select?: string[];
-    /** Include soft-deleted rows (also sets `withDeleted` context). */
-    withDeleted?: boolean;
-}
-/**
- * Type-safe table schema + CRUD operations.
- *
- * Create an instance with {@link pgTable}, then call `.bind(sql)` to get a
- * `BoundTable` for running queries.
- *
- * ```ts
- * const users = pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name').notNull(),
- *   email: text('email').unique(),
- * })
- *
- * const db = users.bind(sql)
- * await db.create()
- * await db.insert({ name: 'Alice', email: 'a@b.com' })
- * const row = await db.findBy({ email: 'a@b.com' })
- * ```
- */
-export declare class Table<R extends Record<string, unknown>> {
-    /** Database table name. */
-    readonly tableName: string;
-    /** All column builders (order-preserving). */
-    readonly columns: ColumnBuilder<unknown>[];
-    /** Column builders keyed by property name. */
-    readonly builders: Record<string, ColumnBuilder<unknown>>;
-    private colEntries;
-    constructor(tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
-    /** Check if the table has a column with the given DB name. */
-    hasColumn(dbName: string): boolean;
-    /**
-     * Bind this table schema to a SQL connection, returning a `BoundTable`
-     * that can run queries without passing `sql` to every call.
-     */
-    bind(sql: SqlClient): BoundTable<R>;
-    /** Returns the primary key column name (DB name), or 'id' as fallback. */
-    private get pkColumn();
-    /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
-    private _softDeleteFilter;
-    create(sql: SqlClient, opts?: CreateOptions): Promise<void>;
-    drop(sql: SqlClient, opts?: {
-        cascade?: boolean;
-    }): Promise<void>;
-    createIndex(sql: SqlClient, columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(sql: SqlClient, columns: string | string[]): Promise<void>;
-    private _buildConditions;
-    private _buildSET;
-    insert(sql: SqlClient, data: Partial<R>): Promise<R>;
-    insertMany(sql: SqlClient, data: Partial<R>[]): Promise<R[]>;
-    read(sql: SqlClient, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(sql: SqlClient, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
-        count: number;
-        data: R[];
-    }>;
-    update(sql: SqlClient, id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(sql: SqlClient, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(sql: SqlClient, id: string | number): Promise<R | undefined>;
-    hardDelete(sql: SqlClient, id: string | number): Promise<R | undefined>;
-    deleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(sql: SqlClient, data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(sql: SqlClient, where?: Partial<R> | SQL | SQL[]): Promise<number>;
-}
-export declare class BoundTable<R extends Record<string, unknown>> {
-    private inner;
-    private sql;
-    /** The underlying table name. */
-    get tableName(): string;
-    constructor(sql: SqlClient, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
-    create(opts?: CreateOptions): Promise<void>;
-    drop(opts?: {
-        cascade?: boolean;
-    }): Promise<void>;
-    createIndex(columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(columns: string | string[]): Promise<void>;
-    insert(data: Partial<R>): Promise<R>;
-    insertMany(data: Partial<R>[]): Promise<R[]>;
-    read(id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
-        count: number;
-        data: R[];
-    }>;
-    update(id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(id: string | number): Promise<R | undefined>;
-    hardDelete(id: string | number): Promise<R | undefined>;
-    deleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(where?: Partial<R> | SQL | SQL[]): Promise<number>;
-    withSql(sql: SqlClient): BoundTable<R>;
-}
-/**
- * Define a type-safe table schema.
- *
- * ```ts
- * const users = pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name').notNull(),
- *   email: text('email').unique(),
- * })
- *
- * // The generic type R preserves the column types:
- * // Table<{ id: number; name: string; email: string }>
- * ```
- */
-export declare function pgTable<R extends Record<string, unknown>>(tableName: string, builders: {
-    [K in keyof R]: ColumnBuilder<R[K]>;
-}): Table<R>;

package/dist/postgres/schema/where.d.ts

@@ -1,29 +0,0 @@
-import { SQL } from './sql.ts';
-/** Column equals value: `col = val`. */
-export declare function eq(col: string, val: unknown): SQL;
-/** Column not equals value: `col != val`. */
-export declare function ne(col: string, val: unknown): SQL;
-/** Column greater than value: `col > val`. */
-export declare function gt(col: string, val: unknown): SQL;
-/** Column greater than or equal value: `col >= val`. */
-export declare function gte(col: string, val: unknown): SQL;
-/** Column less than value: `col < val`. */
-export declare function lt(col: string, val: unknown): SQL;
-/** Column less than or equal value: `col <= val`. */
-export declare function lte(col: string, val: unknown): SQL;
-/** Column IS NULL. */
-export declare function isNull(col: string): SQL;
-/** Column IS NOT NULL. */
-export declare function isNotNull(col: string): SQL;
-/** Column LIKE pattern. */
-export declare function like(col: string, pattern: string): SQL;
-/** Negate a condition: `NOT (condition)`. */
-export declare function not(condition: SQL): SQL;
-/** JSONB containment: `col @> val` (does `col` contain `val`?). */
-export declare function contains(col: string, val: Record<string, unknown>): SQL;
-/** Column value is in array: `col = ANY(val)`. */
-export declare function in_(col: string, val: unknown[]): SQL;
-/** Combine conditions with AND. */
-export declare function and(...conditions: SQL[]): SQL;
-/** Combine conditions with OR. */
-export declare function or(...conditions: SQL[]): SQL;

package/dist/postgres/types.d.ts

@@ -1,50 +0,0 @@
-import type { SqlClient } from '../vendor.ts';
-import type { Context, Middleware, Closeable } from '../types.ts';
-import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
-declare module '../types.ts' {
-    interface Context {
-        sql: SqlClient;
-    }
-}
-export interface PostgresInjected {
-    sql: SqlClient;
-}
-export interface PostgresOptions {
-    connection?: string | Record<string, unknown>;
-    signal?: AbortSignal;
-    closeTimeout?: number;
-    max?: number;
-    ssl?: boolean | Record<string, unknown>;
-    idle_timeout?: number;
-    connect_timeout?: number;
-    /** Per-statement timeout in ms. Set to 0 to disable. Default: 30_000. */
-    statementTimeout?: number;
-    /** Called after every query completes. Receives query text, duration in ms, and row count. */
-    onQuery?: (query: string, durationMs: number, rowCount: number) => void;
-}
-export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
-    sql: SqlClient;
-    /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
-    migrate: () => Promise<void>;
-    /** Record that a module's migration has been applied (idempotent). */
-    markMigrated: (moduleName: string) => Promise<void>;
-    /** Check whether a module has already been migrated. */
-    isMigrated: (moduleName: string) => Promise<boolean>;
-    table: {
-        <R extends Record<string, unknown>>(tableName: string, builders: {
-            [K in keyof R]: ColumnBuilder<R[K]>;
-        }): BoundTable<R>;
-        <R extends Record<string, unknown>>(schema: Table<R>): BoundTable<R>;
-    };
-    transaction: <T>(fn: (sql: any) => Promise<T>, retryOpts?: {
-        maxRetries?: number;
-    }) => Promise<T>;
-    /** Snapshot of connection pool state: active, idle, waiting, max connections. */
-    poolStats: () => {
-        active: number;
-        idle: number;
-        waiting: number;
-        max: number;
-    };
-    close: () => Promise<void>;
-}

package/dist/queue/index.d.ts

@@ -1,2 +0,0 @@
-import type { Queue, QueueOptions } from './types.ts';
-export declare function queue(opts?: QueueOptions): Queue;