tickflow-assist 0.2.0

package/dist/services/trading-calendar-service.d.ts

@@ -0,0 +1,20 @@
+export type TradingPhase = "non_trading_day" | "pre_market" | "trading" | "lunch_break" | "closed";
+export declare class TradingCalendarService {
+    private readonly calendarFile;
+    private cache;
+    constructor(calendarFile: string);
+    isTradingDay(date?: Date): Promise<boolean>;
+    getTradingPhase(date?: Date): Promise<TradingPhase>;
+    canRunDailyUpdate(date?: Date): Promise<{
+        ok: boolean;
+        reason: string;
+    }>;
+    canRunPostCloseReview(date?: Date): Promise<{
+        ok: boolean;
+        reason: string;
+    }>;
+    getRecentTradingDays(limit: number, endDate?: Date): Promise<string[]>;
+    private loadDays;
+    private toChinaDate;
+    private toChinaParts;
+}

package/dist/services/trading-calendar-service.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+export class TradingCalendarService {
+    calendarFile;
+    cache = null;
+    constructor(calendarFile) {
+        this.calendarFile = calendarFile;
+    }
+    async isTradingDay(date = new Date()) {
+        const { daySet } = await this.loadDays();
+        return daySet.has(this.toChinaDate(date));
+    }
+    async getTradingPhase(date = new Date()) {
+        if (!(await this.isTradingDay(date))) {
+            return "non_trading_day";
+        }
+        const china = this.toChinaParts(date);
+        const hhmm = `${china.hour}:${china.minute}`;
+        if (hhmm < "09:30") {
+            return "pre_market";
+        }
+        if (hhmm <= "11:30") {
+            return "trading";
+        }
+        if (hhmm < "13:00") {
+            return "lunch_break";
+        }
+        if (hhmm <= "15:00") {
+            return "trading";
+        }
+        return "closed";
+    }
+    async canRunDailyUpdate(date = new Date()) {
+        if (!(await this.isTradingDay(date))) {
+            return { ok: false, reason: `${this.toChinaDate(date)} 非交易日` };
+        }
+        const china = this.toChinaParts(date);
+        const hhmm = `${china.hour}:${china.minute}`;
+        if (hhmm < "15:25") {
+            return { ok: false, reason: `当前 ${hhmm}，须等到 15:25 后执行` };
+        }
+        return { ok: true, reason: "交易日已收盘" };
+    }
+    async canRunPostCloseReview(date = new Date()) {
+        if (!(await this.isTradingDay(date))) {
+            return { ok: false, reason: `${this.toChinaDate(date)} 非交易日` };
+        }
+        const china = this.toChinaParts(date);
+        const hhmm = `${china.hour}:${china.minute}`;
+        if (hhmm < "20:00") {
+            return { ok: false, reason: `当前 ${hhmm}，须等到 20:00 后执行复盘` };
+        }
+        return { ok: true, reason: "交易日已完成收盘且达到复盘时间" };
+    }
+    async getRecentTradingDays(limit, endDate = new Date()) {
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new Error(`limit must be a positive integer, got ${limit}`);
+        }
+        const { days } = await this.loadDays();
+        const end = this.toChinaDate(endDate);
+        const eligible = days.filter((day) => day <= end);
+        const source = eligible.length > 0 ? eligible : days;
+        return source.slice(-limit);
+    }
+    async loadDays() {
+        if (this.cache) {
+            return this.cache;
+        }
+        const raw = await readFile(this.calendarFile, "utf-8");
+        const days = raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        this.cache = { days, daySet: new Set(days) };
+        return this.cache;
+    }
+    toChinaDate(date) {
+        const parts = this.toChinaParts(date);
+        return `${parts.year}-${parts.month}-${parts.day}`;
+    }
+    toChinaParts(date) {
+        const formatter = new Intl.DateTimeFormat("zh-CN", {
+            timeZone: "Asia/Shanghai",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+        const map = Object.fromEntries(formatter
+            .formatToParts(date)
+            .filter((part) => part.type !== "literal")
+            .map((part) => [part.type, part.value]));
+        return {
+            year: map.year,
+            month: map.month,
+            day: map.day,
+            hour: map.hour,
+            minute: map.minute,
+        };
+    }
+}

package/dist/services/update-service.d.ts

@@ -0,0 +1,21 @@
+import { type TickflowApiKeyLevel } from "../config/tickflow-access.js";
+import { KlineService } from "./kline-service.js";
+import { IndicatorService } from "./indicator-service.js";
+import { KlinesRepository } from "../storage/repositories/klines-repo.js";
+import { IndicatorsRepository } from "../storage/repositories/indicators-repo.js";
+import { IntradayKlinesRepository } from "../storage/repositories/intraday-klines-repo.js";
+import { WatchlistService } from "./watchlist-service.js";
+import { TradingCalendarService } from "./trading-calendar-service.js";
+export declare class UpdateService {
+    private readonly klineService;
+    private readonly tickflowApiKeyLevel;
+    private readonly indicatorService;
+    private readonly klinesRepository;
+    private readonly indicatorsRepository;
+    private readonly intradayKlinesRepository;
+    private readonly watchlistService;
+    private readonly tradingCalendarService;
+    constructor(klineService: KlineService, tickflowApiKeyLevel: TickflowApiKeyLevel, indicatorService: IndicatorService, klinesRepository: KlinesRepository, indicatorsRepository: IndicatorsRepository, intradayKlinesRepository: IntradayKlinesRepository, watchlistService: WatchlistService, tradingCalendarService: TradingCalendarService);
+    updateAll(force?: boolean, days?: number, adjust?: string): Promise<string>;
+    private updateTarget;
+}

package/dist/services/update-service.js

@@ -0,0 +1,130 @@
+import { DEFAULT_MARKET_INDEXES } from "../constants/market-indexes.js";
+import { formatTickflowApiKeyLevel, supportsIntradayKlines } from "../config/tickflow-access.js";
+const INTRADAY_PERIOD = "1m";
+const INTRADAY_RETENTION_DAYS = 30;
+export class UpdateService {
+    klineService;
+    tickflowApiKeyLevel;
+    indicatorService;
+    klinesRepository;
+    indicatorsRepository;
+    intradayKlinesRepository;
+    watchlistService;
+    tradingCalendarService;
+    constructor(klineService, tickflowApiKeyLevel, indicatorService, klinesRepository, indicatorsRepository, intradayKlinesRepository, watchlistService, tradingCalendarService) {
+        this.klineService = klineService;
+        this.tickflowApiKeyLevel = tickflowApiKeyLevel;
+        this.indicatorService = indicatorService;
+        this.klinesRepository = klinesRepository;
+        this.indicatorsRepository = indicatorsRepository;
+        this.intradayKlinesRepository = intradayKlinesRepository;
+        this.watchlistService = watchlistService;
+        this.tradingCalendarService = tradingCalendarService;
+    }
+    async updateAll(force = false, days = 90, adjust = "forward") {
+        if (!force) {
+            const check = await this.tradingCalendarService.canRunDailyUpdate();
+            if (!check.ok) {
+                return `🚫 ${check.reason}`;
+            }
+        }
+        const watchlist = await this.watchlistService.list();
+        const lines = [
+            `📊 收盘更新: ${watchlist.length} 只股票 + ${DEFAULT_MARKET_INDEXES.length} 个指数, 获取 ${days} 天日K与当日分钟K (个股复权: ${adjust})`,
+            `🔑 TickFlow API Key Level: ${formatTickflowApiKeyLevel(this.tickflowApiKeyLevel)}`,
+            "",
+            "📈 指数更新:",
+        ];
+        let indexSuccess = 0;
+        let indexFailed = 0;
+        for (const target of DEFAULT_MARKET_INDEXES) {
+            const result = await this.updateTarget({
+                symbol: target.symbol,
+                name: target.name,
+                kind: "index",
+            }, days, "none");
+            lines.push(result.line);
+            if (result.ok) {
+                indexSuccess += 1;
+            }
+            else {
+                indexFailed += 1;
+            }
+        }
+        let success = 0;
+        let failed = 0;
+        if (watchlist.length === 0) {
+            lines.push("", "📋 关注列表为空，已跳过个股更新");
+        }
+        else {
+            lines.push("", "📋 个股更新:");
+            for (const item of watchlist) {
+                const result = await this.updateTarget({
+                    symbol: item.symbol,
+                    name: item.name,
+                    kind: "stock",
+                }, days, adjust);
+                lines.push(result.line);
+                if (result.ok) {
+                    success += 1;
+                }
+                else {
+                    failed += 1;
+                }
+            }
+        }
+        lines.push(`🏁 完成: 指数 ${indexSuccess} 成功, ${indexFailed} 失败 | 个股 ${success} 成功, ${failed} 失败 (共 ${watchlist.length} 只)`);
+        return lines.join("\n");
+    }
+    async updateTarget(target, days, adjust) {
+        try {
+            const rows = await this.klineService.fetchKlines(target.symbol, {
+                count: days,
+                adjust,
+            });
+            if (rows.length === 0) {
+                return {
+                    ok: false,
+                    line: `❌ ${target.name}（${target.symbol}）: 返回数据为空`,
+                };
+            }
+            await this.klinesRepository.saveAll(target.symbol, rows);
+            const indicators = await this.indicatorService.calculate(rows);
+            await this.indicatorsRepository.saveAll(target.symbol, indicators);
+            let intradaySummary = `分钟K 已跳过（API Key Level=${formatTickflowApiKeyLevel(this.tickflowApiKeyLevel)}）`;
+            if (supportsIntradayKlines(this.tickflowApiKeyLevel)) {
+                try {
+                    const intradayRows = await this.klineService.fetchIntradayKlines(target.symbol, {
+                        period: INTRADAY_PERIOD,
+                    });
+                    if (intradayRows.length > 0) {
+                        await this.intradayKlinesRepository.saveAll(target.symbol, INTRADAY_PERIOD, intradayRows);
+                        const keepTradeDates = await this.tradingCalendarService.getRecentTradingDays(INTRADAY_RETENTION_DAYS, new Date(intradayRows[intradayRows.length - 1].timestamp));
+                        await this.intradayKlinesRepository.pruneToTradeDates(target.symbol, INTRADAY_PERIOD, keepTradeDates);
+                        intradaySummary = `分钟K ${intradayRows.length} 根`;
+                    }
+                    else {
+                        intradaySummary = "分钟K 0 根";
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    intradaySummary = `分钟K 更新失败，已跳过（${message}）`;
+                }
+            }
+            const latest = rows[rows.length - 1];
+            const scope = target.kind === "index" ? "指数" : "个股";
+            return {
+                ok: true,
+                line: `✅ ${target.name}（${target.symbol}）: ${scope}日K ${rows.length} 根, ${intradaySummary}, 最新 ${latest.trade_date} 收盘 ${latest.close.toFixed(2)}`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                line: `❌ ${target.name}（${target.symbol}）: ${message}`,
+            };
+        }
+    }
+}

package/dist/services/watchlist-profile-service.d.ts

@@ -0,0 +1,20 @@
+import { AnalysisService } from "./analysis-service.js";
+import type { MxSearchDocument } from "../types/mx-search.js";
+import { MxApiService } from "./mx-search-service.js";
+export interface WatchlistProfile {
+    sector: string | null;
+    themes: string[];
+    themeQuery: string | null;
+    themeUpdatedAt: string | null;
+}
+export declare class WatchlistProfileService {
+    private readonly mxApiService;
+    private readonly analysisService;
+    constructor(mxApiService: MxApiService, analysisService: AnalysisService);
+    resolve(symbol: string, companyName: string, updatedAt: string): Promise<WatchlistProfile>;
+}
+export declare function buildBoardNewsQuery(profile: {
+    sector: string | null;
+    themes: string[];
+}): string | null;
+export declare function formatWatchlistProfileDocuments(documents: MxSearchDocument[]): string;

package/dist/services/watchlist-profile-service.js

@@ -0,0 +1,76 @@
+import { parseWatchlistProfileExtraction } from "../analysis/parsers/watchlist-profile.parser.js";
+import { buildWatchlistProfileExtractionUserPrompt, WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, } from "../prompts/analysis/index.js";
+const MAX_PROFILE_DOCUMENTS = 8;
+export class WatchlistProfileService {
+    mxApiService;
+    analysisService;
+    constructor(mxApiService, analysisService) {
+        this.mxApiService = mxApiService;
+        this.analysisService = analysisService;
+    }
+    async resolve(symbol, companyName, updatedAt) {
+        const themeQuery = buildThemeQuery(companyName, symbol);
+        const mxConfigError = this.mxApiService.getConfigurationError();
+        if (mxConfigError) {
+            throw new Error(mxConfigError);
+        }
+        const llmConfigError = this.analysisService.getConfigurationError();
+        if (llmConfigError) {
+            throw new Error(llmConfigError);
+        }
+        const documents = (await this.mxApiService.search(themeQuery)).slice(0, MAX_PROFILE_DOCUMENTS);
+        if (documents.length === 0) {
+            return {
+                sector: null,
+                themes: [],
+                themeQuery,
+                themeUpdatedAt: updatedAt,
+            };
+        }
+        const responseText = await this.analysisService.generateText(WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, buildWatchlistProfileExtractionUserPrompt({
+            symbol,
+            companyName,
+            documents,
+        }), {
+            maxTokens: 1200,
+            temperature: 0.1,
+        });
+        const profile = parseWatchlistProfileExtraction(responseText);
+        if (!profile) {
+            throw new Error(`watchlist profile extraction returned invalid JSON for ${symbol}`);
+        }
+        return {
+            sector: profile.sector,
+            themes: profile.themes,
+            themeQuery,
+            themeUpdatedAt: updatedAt,
+        };
+    }
+}
+export function buildBoardNewsQuery(profile) {
+    const keywords = [
+        String(profile.sector ?? "").trim(),
+        ...profile.themes
+            .map((item) => String(item ?? "").trim())
+            .filter(Boolean)
+            .slice(0, 3),
+    ].filter(Boolean);
+    if (keywords.length === 0) {
+        return null;
+    }
+    return `${keywords.join(" ")} 板块 题材 最新新闻 政策 资金`;
+}
+function buildThemeQuery(companyName, symbol) {
+    return `${companyName} ${symbol} 所属行业 板块 题材 概念`;
+}
+export function formatWatchlistProfileDocuments(documents) {
+    return documents
+        .slice(0, MAX_PROFILE_DOCUMENTS)
+        .map((document, index) => [
+        `${index + 1}. ${document.title}`,
+        `来源: ${document.source ?? "未知"}`,
+        `时间: ${document.publishedAt ?? "未知"}`,
+        `正文: ${document.trunk || "无"}`,
+    ].join("\n"))
+        .join("\n\n");
+}

package/dist/services/watchlist-service.d.ts

@@ -0,0 +1,43 @@
+import type { WatchlistItem } from "../types/domain.js";
+import { InstrumentService } from "./instrument-service.js";
+import { WatchlistRepository } from "../storage/repositories/watchlist-repo.js";
+import { WatchlistProfileService } from "./watchlist-profile-service.js";
+interface GetWatchlistItemOptions {
+    refreshConceptBoards?: boolean;
+}
+export interface AddWatchlistResult {
+    item: WatchlistItem;
+    profileError: string | null;
+}
+export interface RefreshWatchlistProfilesOptions {
+    symbol?: string;
+    force?: boolean;
+}
+export interface WatchlistProfileRefreshFailure {
+    symbol: string;
+    name: string;
+    error: string;
+}
+export interface RefreshWatchlistProfilesResult {
+    targetCount: number;
+    updated: WatchlistItem[];
+    rechecked: WatchlistItem[];
+    failed: WatchlistProfileRefreshFailure[];
+}
+export declare class WatchlistService {
+    private readonly repository;
+    private readonly instrumentService;
+    private readonly watchlistProfileService;
+    constructor(repository: WatchlistRepository, instrumentService: InstrumentService, watchlistProfileService?: WatchlistProfileService | null);
+    add(symbolInput: string, costPrice?: number | null): Promise<AddWatchlistResult>;
+    list(): Promise<WatchlistItem[]>;
+    remove(symbolInput: string): Promise<boolean>;
+    getBySymbol(symbolInput: string, options?: GetWatchlistItemOptions): Promise<WatchlistItem | null>;
+    refreshProfiles(options?: RefreshWatchlistProfilesOptions): Promise<RefreshWatchlistProfilesResult>;
+    refreshNames(): Promise<{
+        updated: WatchlistItem[];
+        unchanged: WatchlistItem[];
+    }>;
+    private refreshConceptProfile;
+}
+export {};

package/dist/services/watchlist-service.js

@@ -0,0 +1,204 @@
+import { formatChinaDateTime } from "../utils/china-time.js";
+import { normalizeSymbol } from "../utils/symbol.js";
+import { normalizeCostPrice } from "../utils/cost-price.js";
+const CONCEPT_BOARD_REFRESH_DAYS = 5;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+export class WatchlistService {
+    repository;
+    instrumentService;
+    watchlistProfileService;
+    constructor(repository, instrumentService, watchlistProfileService = null) {
+        this.repository = repository;
+        this.instrumentService = instrumentService;
+        this.watchlistProfileService = watchlistProfileService;
+    }
+    async add(symbolInput, costPrice = null) {
+        const symbol = normalizeSymbol(symbolInput);
+        const existing = await this.getBySymbol(symbol);
+        const normalizedCostPrice = normalizeCostPrice(costPrice);
+        const name = await this.instrumentService.resolveName(symbol);
+        const addedAt = formatChinaDateTime();
+        const fallbackProfile = {
+            sector: existing?.sector ?? null,
+            themes: existing?.themes ?? [],
+            themeQuery: existing?.themeQuery ?? null,
+            themeUpdatedAt: existing?.themeUpdatedAt ?? null,
+        };
+        let profile = fallbackProfile;
+        let profileError = null;
+        if (this.watchlistProfileService) {
+            try {
+                const resolved = await this.watchlistProfileService.resolve(symbol, name, addedAt);
+                profile = {
+                    sector: resolved.sector ?? fallbackProfile.sector,
+                    themes: resolved.themes.length > 0 ? resolved.themes : fallbackProfile.themes,
+                    themeQuery: resolved.themeQuery ?? fallbackProfile.themeQuery,
+                    themeUpdatedAt: resolved.themeUpdatedAt ?? fallbackProfile.themeUpdatedAt,
+                };
+            }
+            catch (error) {
+                profileError = toErrorMessage(error);
+            }
+        }
+        const item = {
+            symbol,
+            name,
+            costPrice: normalizedCostPrice ?? existing?.costPrice ?? null,
+            addedAt,
+            sector: profile.sector,
+            themes: profile.themes,
+            themeQuery: profile.themeQuery,
+            themeUpdatedAt: profile.themeUpdatedAt,
+        };
+        await this.repository.upsert(item);
+        return { item, profileError };
+    }
+    async list() {
+        return this.repository.list();
+    }
+    async remove(symbolInput) {
+        const symbol = normalizeSymbol(symbolInput);
+        return this.repository.remove(symbol);
+    }
+    async getBySymbol(symbolInput, options = {}) {
+        const symbol = normalizeSymbol(symbolInput);
+        const items = await this.repository.list();
+        const item = items.find((entry) => entry.symbol === symbol) ?? null;
+        if (!item || !options.refreshConceptBoards) {
+            return item;
+        }
+        const result = await this.refreshConceptProfile(item, { force: false });
+        return result.item;
+    }
+    async refreshProfiles(options = {}) {
+        const items = await this.repository.list();
+        const targetSymbol = options.symbol ? normalizeSymbol(options.symbol) : null;
+        const targets = targetSymbol
+            ? items.filter((item) => item.symbol === targetSymbol)
+            : items;
+        const result = {
+            targetCount: targets.length,
+            updated: [],
+            rechecked: [],
+            failed: [],
+        };
+        if (targets.length === 0) {
+            return result;
+        }
+        if (!this.watchlistProfileService) {
+            result.failed = targets.map((item) => ({
+                symbol: item.symbol,
+                name: item.name,
+                error: "watchlist profile service unavailable",
+            }));
+            return result;
+        }
+        const force = options.force ?? true;
+        for (const item of targets) {
+            try {
+                const refreshed = await this.refreshConceptProfile(item, { force });
+                if (refreshed.status === "updated") {
+                    result.updated.push(refreshed.item);
+                    continue;
+                }
+                if (refreshed.status === "rechecked") {
+                    result.rechecked.push(refreshed.item);
+                }
+            }
+            catch (error) {
+                result.failed.push({
+                    symbol: item.symbol,
+                    name: item.name,
+                    error: toErrorMessage(error),
+                });
+            }
+        }
+        return result;
+    }
+    async refreshNames() {
+        const items = await this.repository.list();
+        const updated = [];
+        const unchanged = [];
+        for (const item of items) {
+            const nextName = await this.instrumentService.resolveName(item.symbol);
+            const normalizedCurrent = sanitizeName(item.name, item.symbol);
+            if (normalizedCurrent === nextName) {
+                unchanged.push({ ...item, name: normalizedCurrent });
+                continue;
+            }
+            const nextItem = { ...item, name: nextName };
+            await this.repository.upsert(nextItem);
+            updated.push(nextItem);
+        }
+        return { updated, unchanged };
+    }
+    async refreshConceptProfile(item, options) {
+        if (!this.watchlistProfileService) {
+            return { item, status: "skipped" };
+        }
+        if (!options.force && !shouldRefreshConceptBoards(item)) {
+            return { item, status: "skipped" };
+        }
+        const refreshedAt = formatChinaDateTime();
+        const profile = await this.watchlistProfileService.resolve(item.symbol, item.name, refreshedAt);
+        const nextItem = {
+            ...item,
+            sector: profile.sector ?? item.sector ?? null,
+            themes: profile.themes.length > 0 ? profile.themes : item.themes,
+            themeQuery: profile.themeQuery ?? item.themeQuery ?? null,
+            themeUpdatedAt: profile.themeUpdatedAt ?? item.themeUpdatedAt ?? null,
+        };
+        const profileChanged = !hasSameConceptProfileContent(item, nextItem);
+        const timestampChanged = item.themeUpdatedAt !== nextItem.themeUpdatedAt;
+        if (profileChanged || timestampChanged) {
+            await this.repository.upsert(nextItem);
+        }
+        return {
+            item: profileChanged || timestampChanged ? nextItem : item,
+            status: profileChanged ? "updated" : "rechecked",
+        };
+    }
+}
+function shouldRefreshConceptBoards(item) {
+    if (!item.sector || item.themes.length === 0 || !item.themeUpdatedAt) {
+        return true;
+    }
+    const updatedAt = parseChinaTimestamp(item.themeUpdatedAt);
+    if (updatedAt == null) {
+        return true;
+    }
+    return Date.now() - updatedAt >= CONCEPT_BOARD_REFRESH_DAYS * ONE_DAY_MS;
+}
+function parseChinaTimestamp(value) {
+    const text = value.trim();
+    if (!text) {
+        return null;
+    }
+    const isoLike = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(text)
+        ? `${text.replace(" ", "T")}+08:00`
+        : text;
+    const timestamp = Date.parse(isoLike);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function hasSameConceptProfileContent(left, right) {
+    return left.sector === right.sector
+        && left.themeQuery === right.themeQuery
+        && left.themes.length === right.themes.length
+        && left.themes.every((value, index) => value === right.themes[index]);
+}
+function sanitizeName(name, symbol) {
+    const trimmed = (name || "").trim();
+    if (!trimmed) {
+        return symbol;
+    }
+    if (trimmed === symbol) {
+        return symbol;
+    }
+    if (trimmed.includes("http://") || trimmed.includes("https://")) {
+        return symbol;
+    }
+    return trimmed;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/storage/db.d.ts

@@ -0,0 +1,23 @@
+type LanceDbModule = typeof import("@lancedb/lancedb");
+type LanceConnection = Awaited<ReturnType<LanceDbModule["connect"]>>;
+type LanceTable = Awaited<ReturnType<LanceConnection["openTable"]>>;
+export type DbRow = Record<string, unknown>;
+export type DbSchema = Awaited<ReturnType<LanceTable["schema"]>>;
+export declare class Database {
+    private readonly baseDir;
+    constructor(baseDir: string);
+    getConnection(): Promise<LanceConnection>;
+    hasTable(name: string): Promise<boolean>;
+    listTables(): Promise<string[]>;
+    openTable(name: string): Promise<LanceTable>;
+    createTable(name: string, rows: DbRow[], schema?: DbSchema): Promise<LanceTable>;
+    tableToArray<T>(name: string): Promise<T[]>;
+    describeTable(name: string): Promise<Array<{
+        name: string;
+        type: string;
+        nullable: boolean;
+    }>>;
+    private connect;
+    private listTableNames;
+}
+export {};