llm-simple-router 0.1.0

package/dist/index.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import Fastify from "fastify";
+const HTTP_NOT_FOUND = 404;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { getConfig } from "./config.js";
+import { initDatabase, seedDefaultRules } from "./db/index.js";
+import { authMiddleware } from "./middleware/auth.js";
+import { openaiProxy } from "./proxy/openai.js";
+import { anthropicProxy } from "./proxy/anthropic.js";
+import { adminRoutes } from "./admin/routes.js";
+import { RetryRuleMatcher } from "./proxy/retry-rules.js";
+import fastifyStatic from "@fastify/static";
+export async function buildApp(options) {
+    const config = options?.config ?? getConfig();
+    // 允许外部传入已初始化的 DB（测试用），否则自行创建
+    let db;
+    if (options?.db) {
+        db = options.db;
+    }
+    else {
+        db = initDatabase(config.DB_PATH);
+    }
+    const app = Fastify({
+        logger: {
+            level: config.LOG_LEVEL,
+        },
+        // 统一 schema validation 错误格式为 { error: { message } }
+        ajv: {
+            customOptions: {
+                messages: true,
+            },
+        },
+    });
+    app.setSchemaErrorFormatter((errors) => {
+        const message = errors
+            .map((e) => {
+            const field = e.instancePath ? e.instancePath.slice(1) : e.params?.missingProperty ?? "field";
+            return `${field} ${e.message}`;
+        })
+            .join("; ");
+        return new Error(message);
+    });
+    // 统一 schema validation 错误响应格式
+    app.setErrorHandler((error, _request, reply) => {
+        const fastifyError = error;
+        const status = fastifyError.statusCode ?? 500;
+        if (status === 400 && fastifyError.validation) {
+            return reply.code(400).send({ error: { message: fastifyError.message } });
+        }
+        return reply.code(status).send({ error: { message: fastifyError.message } });
+    });
+    // 首次启动时插入默认重试规则（表为空时）
+    seedDefaultRules(db);
+    const matcher = new RetryRuleMatcher();
+    matcher.load(db);
+    app.register(authMiddleware, { db });
+    app.register(openaiProxy, {
+        db,
+        encryptionKey: config.ENCRYPTION_KEY,
+        streamTimeoutMs: config.STREAM_TIMEOUT_MS,
+        retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
+        retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
+        matcher,
+    });
+    app.register(anthropicProxy, {
+        db,
+        encryptionKey: config.ENCRYPTION_KEY,
+        streamTimeoutMs: config.STREAM_TIMEOUT_MS,
+        retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
+        retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
+        matcher,
+    });
+    app.register(adminRoutes, {
+        db,
+        adminPassword: config.ADMIN_PASSWORD,
+        jwtSecret: config.JWT_SECRET,
+        encryptionKey: config.ENCRYPTION_KEY,
+        matcher,
+    });
+    // 前端静态文件服务（生产环境）
+    const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(__dirname, "../frontend-dist"));
+    if (existsSync(frontendDist)) {
+        app.register(fastifyStatic, {
+            root: frontendDist,
+            prefix: "/admin/",
+            wildcard: false,
+        });
+        // SPA fallback: /admin/ 下非 API 路径返回 index.html
+        app.setNotFoundHandler((request, reply) => {
+            if (request.url.startsWith("/admin") &&
+                !request.url.startsWith("/admin/api")) {
+                return reply.sendFile("index.html");
+            }
+            reply.code(HTTP_NOT_FOUND).send({ error: "Not Found" });
+        });
+    }
+    else {
+        app.log.warn(`Frontend dist not found at ${frontendDist}, skipping static serving`);
+    }
+    app.get("/health", async () => {
+        return { status: "ok" };
+    });
+    return {
+        app,
+        db,
+        close: async () => {
+            await app.close();
+            db.close();
+        },
+    };
+}
+async function main() {
+    const { app } = await buildApp();
+    const config = getConfig();
+    try {
+        await app.listen({ port: config.PORT, host: "0.0.0.0" });
+        app.log.info(`Server listening on port ${config.PORT}`);
+    }
+    catch (err) {
+        app.log.error(err);
+        process.exit(1);
+    }
+}
+const isMainModule = process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts");
+if (isMainModule) {
+    main();
+}

package/dist/metrics/metrics-extractor.d.ts

@@ -0,0 +1,32 @@
+import type { SSEEvent } from "./sse-parser.js";
+export interface MetricsResult {
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cache_creation_tokens: number | null;
+    cache_read_tokens: number | null;
+    ttft_ms: number | null;
+    total_duration_ms: number | null;
+    tokens_per_second: number | null;
+    stop_reason: string | null;
+    is_complete: number;
+}
+export declare class MetricsExtractor {
+    private apiType;
+    private requestStartTime;
+    private inputTokens;
+    private outputTokens;
+    private cacheCreationTokens;
+    private cacheReadTokens;
+    private ttftMs;
+    private streamStartTime;
+    private streamEndTime;
+    private stopReason;
+    private firstContentReceived;
+    private complete;
+    constructor(apiType: "openai" | "anthropic", requestStartTime: number);
+    processEvent(event: SSEEvent): void;
+    getMetrics(): MetricsResult;
+    static fromNonStreamResponse(apiType: "openai" | "anthropic", responseBody: string): MetricsResult | null;
+    private processAnthropicEvent;
+    private processOpenAIEvent;
+}

package/dist/metrics/metrics-extractor.js

@@ -0,0 +1,178 @@
+const MS_PER_SECOND = 1000;
+export class MetricsExtractor {
+    apiType;
+    requestStartTime;
+    inputTokens = null;
+    outputTokens = null;
+    cacheCreationTokens = null;
+    cacheReadTokens = null;
+    ttftMs = null;
+    streamStartTime = null;
+    streamEndTime = null;
+    stopReason = null;
+    firstContentReceived = false;
+    complete = false;
+    constructor(apiType, requestStartTime) {
+        this.apiType = apiType;
+        this.requestStartTime = requestStartTime;
+    }
+    processEvent(event) {
+        if (!event.data)
+            return;
+        if (this.apiType === "anthropic") {
+            this.processAnthropicEvent(event);
+        }
+        else {
+            this.processOpenAIEvent(event);
+        }
+    }
+    getMetrics() {
+        let totalDurationMs = null;
+        let tokensPerSecond = null;
+        if (this.streamStartTime !== null &&
+            this.streamEndTime !== null &&
+            this.outputTokens !== null) {
+            totalDurationMs = this.streamEndTime - this.streamStartTime;
+            if (totalDurationMs > 0) {
+                tokensPerSecond =
+                    this.outputTokens / (totalDurationMs / MS_PER_SECOND);
+            }
+        }
+        return {
+            input_tokens: this.inputTokens,
+            output_tokens: this.outputTokens,
+            cache_creation_tokens: this.cacheCreationTokens,
+            cache_read_tokens: this.cacheReadTokens,
+            ttft_ms: this.ttftMs,
+            total_duration_ms: totalDurationMs,
+            tokens_per_second: tokensPerSecond,
+            stop_reason: this.stopReason,
+            is_complete: this.complete ? 1 : 0,
+        };
+    }
+    static fromNonStreamResponse(apiType, responseBody) {
+        let parsed;
+        try {
+            parsed = JSON.parse(responseBody);
+        }
+        catch {
+            return null;
+        }
+        if (apiType === "openai") {
+            return extractOpenAINonStream(parsed);
+        }
+        return extractAnthropicNonStream(parsed);
+    }
+    processAnthropicEvent(event) {
+        let parsed;
+        try {
+            parsed = JSON.parse(event.data);
+        }
+        catch {
+            return;
+        }
+        const type = parsed.type;
+        if (type === "message_start") {
+            const msg = parsed;
+            const usage = msg.message?.usage;
+            if (usage) {
+                this.inputTokens = usage.input_tokens ?? null;
+                this.cacheCreationTokens = usage.cache_creation_input_tokens ?? null;
+                this.cacheReadTokens = usage.cache_read_input_tokens ?? null;
+            }
+            this.streamStartTime = Date.now();
+        }
+        else if (type === "content_block_delta") {
+            // 首次收到内容时记录 TTFT（不管是 thinking_delta 还是 text_delta）
+            if (!this.firstContentReceived) {
+                this.firstContentReceived = true;
+                this.ttftMs = Date.now() - this.requestStartTime;
+            }
+        }
+        else if (type === "message_delta") {
+            const msg = parsed;
+            this.outputTokens = msg.usage?.output_tokens ?? null;
+            this.stopReason = msg.delta?.stop_reason ?? null;
+            this.streamEndTime = Date.now();
+        }
+        else if (type === "message_stop") {
+            this.complete = true;
+        }
+    }
+    processOpenAIEvent(event) {
+        // SSEParser 通常会拦截 [DONE]，但以防直接传入
+        if (event.data === "[DONE]") {
+            this.complete = true;
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(event.data);
+        }
+        catch {
+            return;
+        }
+        const choices = parsed.choices;
+        if (choices && choices.length > 0) {
+            const choice = choices[0];
+            const delta = choice.delta;
+            // 跳过只有 role 的 chunk，不视为内容
+            if (!this.firstContentReceived &&
+                delta &&
+                delta.content !== undefined &&
+                delta.content !== "") {
+                this.firstContentReceived = true;
+                this.ttftMs = Date.now() - this.requestStartTime;
+            }
+            if (choice.finish_reason) {
+                this.stopReason = choice.finish_reason;
+                this.streamEndTime = Date.now();
+            }
+        }
+        // usage 通常在最后一个 chunk 中
+        if (parsed.usage) {
+            this.inputTokens = parsed.usage.prompt_tokens ?? null;
+            this.outputTokens = parsed.usage.completion_tokens ?? null;
+            this.cacheReadTokens =
+                parsed.usage.prompt_tokens_details?.cached_tokens ?? null;
+            // usage chunk 标志流结束，确保 duration 可计算
+            if (this.streamStartTime === null) {
+                this.streamStartTime = this.requestStartTime;
+            }
+            if (this.streamEndTime === null) {
+                this.streamEndTime = Date.now();
+            }
+        }
+    }
+}
+function extractOpenAINonStream(parsed) {
+    const usage = parsed.usage;
+    const choices = parsed.choices;
+    const stopReason = choices?.[0]?.finish_reason ?? null;
+    const details = usage?.prompt_tokens_details;
+    return {
+        input_tokens: usage?.prompt_tokens ?? null,
+        output_tokens: usage?.completion_tokens ?? null,
+        cache_creation_tokens: null,
+        cache_read_tokens: details?.cached_tokens ?? null,
+        ttft_ms: null,
+        total_duration_ms: null,
+        tokens_per_second: null,
+        stop_reason: stopReason,
+        is_complete: 1,
+    };
+}
+function extractAnthropicNonStream(parsed) {
+    const usage = parsed.usage;
+    return {
+        input_tokens: usage?.input_tokens ?? null,
+        output_tokens: usage?.output_tokens ?? null,
+        cache_creation_tokens: usage?.cache_creation_input_tokens ?? null,
+        cache_read_tokens: usage?.cache_read_input_tokens ?? null,
+        ttft_ms: null,
+        total_duration_ms: null,
+        tokens_per_second: null,
+        stop_reason: parsed.stop_reason ?? null,
+        is_complete: 1,
+    };
+}

package/dist/metrics/sse-metrics-transform.d.ts

@@ -0,0 +1,16 @@
+import { Transform, TransformCallback } from "stream";
+import { MetricsExtractor } from "./metrics-extractor.js";
+/**
+ * 旁路采集 SSE 指标的 Transform stream
+ *
+ * 管道位置: upstream → SSEMetricsTransform → PassThrough → reply.raw
+ * 不修改流经的数据，仅解析 SSE 事件并提取指标。
+ */
+export declare class SSEMetricsTransform extends Transform {
+    private parser;
+    private extractor;
+    constructor(apiType: "openai" | "anthropic", requestStartTime: number);
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    getExtractor(): MetricsExtractor;
+}

package/dist/metrics/sse-metrics-transform.js

@@ -0,0 +1,35 @@
+import { Transform } from "stream";
+import { SSEParser } from "./sse-parser.js";
+import { MetricsExtractor } from "./metrics-extractor.js";
+/**
+ * 旁路采集 SSE 指标的 Transform stream
+ *
+ * 管道位置: upstream → SSEMetricsTransform → PassThrough → reply.raw
+ * 不修改流经的数据，仅解析 SSE 事件并提取指标。
+ */
+export class SSEMetricsTransform extends Transform {
+    parser;
+    extractor;
+    constructor(apiType, requestStartTime) {
+        super();
+        this.parser = new SSEParser();
+        this.extractor = new MetricsExtractor(apiType, requestStartTime);
+    }
+    _transform(chunk, _encoding, callback) {
+        const events = this.parser.feed(chunk.toString("utf-8"));
+        for (const event of events) {
+            this.extractor.processEvent(event);
+        }
+        callback(null, chunk);
+    }
+    _flush(callback) {
+        const events = this.parser.flush();
+        for (const event of events) {
+            this.extractor.processEvent(event);
+        }
+        callback();
+    }
+    getExtractor() {
+        return this.extractor;
+    }
+}

package/dist/metrics/sse-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SSE 行缓冲解析器
+ *
+ * 将 TCP 流中分片的文本块按 SSE 协议解析为结构化事件。
+ * 不是 Transform stream，而是纯解析类，由上层 Transform 调用。
+ */
+export interface SSEEvent {
+    event?: string;
+    data?: string;
+}
+export declare class SSEParser {
+    private buffer;
+    isDone: boolean;
+    feed(chunk: string): SSEEvent[];
+    flush(): SSEEvent[];
+    private drainEvents;
+    private parseBlock;
+    /** 提取 field 冒号后的值，去除首个空格（SSE 规范: "data: value" -> "value"） */
+    private extractFieldValue;
+}

package/dist/metrics/sse-parser.js

@@ -0,0 +1,81 @@
+export class SSEParser {
+    buffer = "";
+    isDone = false;
+    feed(chunk) {
+        if (this.isDone)
+            return [];
+        this.buffer += chunk;
+        return this.drainEvents();
+    }
+    flush() {
+        const events = this.drainEvents();
+        // 末尾没有 \n\n 的残余数据也尝试解析
+        if (this.buffer.trim()) {
+            const event = this.parseBlock(this.buffer);
+            if (event)
+                events.push(event);
+        }
+        this.buffer = "";
+        return events;
+    }
+    drainEvents() {
+        const events = [];
+        // SSE 事件块以 \n\n 分隔
+        while (true) {
+            const idx = this.buffer.indexOf("\n\n");
+            if (idx === -1)
+                break;
+            const block = this.buffer.slice(0, idx);
+            // +2 跳过 "\n\n" 分隔符
+            this.buffer = this.buffer.slice(idx + "\n\n".length);
+            const event = this.parseBlock(block);
+            if (event)
+                events.push(event);
+            if (this.isDone)
+                break;
+        }
+        return events;
+    }
+    parseBlock(block) {
+        const lines = block.split("\n");
+        let eventType;
+        const dataLines = [];
+        for (const line of lines) {
+            // 空行在 block 内部忽略（block 边界已由 \n\n 处理）
+            if (line === "")
+                continue;
+            // SSE 注释行
+            if (line.startsWith(":"))
+                continue;
+            if (line.startsWith("event:")) {
+                eventType = this.extractFieldValue(line);
+            }
+            else if (line.startsWith("data:")) {
+                const value = this.extractFieldValue(line);
+                // [DONE] 是流结束信号，不作为普通事件返回
+                if (value === "[DONE]") {
+                    this.isDone = true;
+                    return null;
+                }
+                dataLines.push(value);
+            }
+            // 其他 field（id:, retry:, etc.）按 SSE 规范忽略
+        }
+        // 没有 data 的事件块无意义
+        if (dataLines.length === 0)
+            return null;
+        return {
+            event: eventType,
+            data: dataLines.join("\n"),
+        };
+    }
+    /** 提取 field 冒号后的值，去除首个空格（SSE 规范: "data: value" -> "value"） */
+    extractFieldValue(line) {
+        const colonIdx = line.indexOf(":");
+        let value = line.slice(colonIdx + 1);
+        // 第一个字符是空格时去除
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        return value;
+    }
+}

package/dist/middleware/admin-auth.d.ts

@@ -0,0 +1,8 @@
+import { FastifyPluginCallback } from "fastify";
+interface AdminAuthOptions {
+    adminPassword: string;
+    jwtSecret: string;
+}
+export declare const adminAuthPlugin: FastifyPluginCallback<AdminAuthOptions>;
+export declare const adminLoginRoutes: FastifyPluginCallback<AdminAuthOptions>;
+export {};

package/dist/middleware/admin-auth.js

@@ -0,0 +1,57 @@
+import fp from "fastify-plugin";
+import cookie from "@fastify/cookie";
+import jwt from "jsonwebtoken";
+import { timingSafeEqual } from "crypto";
+const HTTP_UNAUTHORIZED = 401;
+const adminAuthRaw = (app, options, done) => {
+    app.register(cookie);
+    app.addHook("onRequest", async (request, reply) => {
+        const path = request.url.split("?")[0];
+        if (!path.startsWith("/admin/api/") || path === "/admin/api/login" || path === "/admin/api/logout") {
+            return;
+        }
+        const token = request.cookies["admin_token"];
+        if (!token) {
+            reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Not authenticated" } });
+            return reply;
+        }
+        try {
+            jwt.verify(token, options.jwtSecret);
+        }
+        catch (err) {
+            request.log.debug({ err }, "invalid JWT token");
+            reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid or expired token" } });
+            return reply;
+        }
+    });
+    done();
+};
+export const adminAuthPlugin = fp(adminAuthRaw, { name: "admin-auth" });
+export const adminLoginRoutes = (app, options, done) => {
+    const TOKEN_EXPIRY_SECONDS = 86400;
+    app.post("/admin/api/login", async (request, reply) => {
+        const { password } = request.body;
+        if (!password) {
+            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
+        }
+        const passwordBuf = Buffer.from(password);
+        const keyBuf = Buffer.from(options.adminPassword);
+        if (passwordBuf.length !== keyBuf.length || !timingSafeEqual(passwordBuf, keyBuf)) {
+            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
+        }
+        const token = jwt.sign({ role: "admin" }, options.jwtSecret, { expiresIn: TOKEN_EXPIRY_SECONDS });
+        reply.setCookie("admin_token", token, {
+            path: "/admin",
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "lax",
+            maxAge: TOKEN_EXPIRY_SECONDS,
+        });
+        return reply.send({ success: true });
+    });
+    app.post("/admin/api/logout", async (_request, reply) => {
+        reply.clearCookie("admin_token", { path: "/admin" });
+        return reply.send({ success: true });
+    });
+    done();
+};

package/dist/middleware/auth.d.ts

@@ -0,0 +1,14 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+declare module "fastify" {
+    interface FastifyRequest {
+        routerKey?: {
+            id: string;
+            name: string;
+            allowed_models: string | null;
+        };
+    }
+}
+export declare const authMiddleware: FastifyPluginCallback<{
+    db: Database.Database;
+}>;

package/dist/middleware/auth.js

@@ -0,0 +1,41 @@
+import { createHash } from "crypto";
+import fp from "fastify-plugin";
+const SKIP_PATHS = ["/health", "/admin"];
+const HTTP_UNAUTHORIZED = 401;
+const BEARER_PREFIX_LENGTH = "Bearer ".length;
+function shouldSkipAuth(url) {
+    const path = url.split("?")[0];
+    return SKIP_PATHS.some((prefix) => path === prefix || path.startsWith(prefix + "/"));
+}
+function unauthorizedReply(reply) {
+    reply.code(HTTP_UNAUTHORIZED).send({
+        error: {
+            message: "Invalid API key",
+            type: "invalid_request_error",
+            code: "invalid_api_key",
+        },
+    });
+}
+const authMiddlewareRaw = (app, options, done) => {
+    const stmt = options.db.prepare("SELECT id, name, allowed_models FROM router_keys WHERE key_hash = ? AND is_active = 1");
+    app.addHook("onRequest", async (request, reply) => {
+        if (shouldSkipAuth(request.url)) {
+            return;
+        }
+        const authHeader = request.headers.authorization;
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            unauthorizedReply(reply);
+            return reply;
+        }
+        const token = authHeader.slice(BEARER_PREFIX_LENGTH);
+        const hash = createHash("sha256").update(token).digest("hex");
+        const row = stmt.get(hash);
+        if (!row) {
+            unauthorizedReply(reply);
+            return reply;
+        }
+        request.routerKey = { id: row.id, name: row.name, allowed_models: row.allowed_models };
+    });
+    done();
+};
+export const authMiddleware = fp(authMiddlewareRaw, { name: "auth-middleware" });

package/dist/proxy/anthropic.d.ts

@@ -0,0 +1,12 @@
+import Database from "better-sqlite3";
+import type { FastifyPluginCallback } from "fastify";
+import { RetryRuleMatcher } from "./retry-rules.js";
+export interface AnthropicProxyOptions {
+    db: Database.Database;
+    encryptionKey: string;
+    streamTimeoutMs: number;
+    retryMaxAttempts: number;
+    retryBaseDelayMs: number;
+    matcher?: RetryRuleMatcher;
+}
+export declare const anthropicProxy: FastifyPluginCallback<AnthropicProxyOptions>;

package/dist/proxy/anthropic.js

@@ -0,0 +1,34 @@
+import fp from "fastify-plugin";
+import { handleProxyPost, } from "./proxy-core.js";
+const MESSAGES_PATH = "/v1/messages";
+const anthropicErrors = {
+    modelNotFound: (model) => ({
+        statusCode: 404,
+        body: { type: "error", error: { type: "not_found_error", message: `Model '${model}' is not configured` } },
+    }),
+    modelNotAllowed: (model) => ({
+        statusCode: 403,
+        body: { type: "error", error: { type: "forbidden_error", message: `Model '${model}' is not allowed for this API key` } },
+    }),
+    providerUnavailable: () => ({
+        statusCode: 503,
+        body: { type: "error", error: { type: "api_error", message: "Provider unavailable" } },
+    }),
+    providerTypeMismatch: () => ({
+        statusCode: 500,
+        body: { type: "error", error: { type: "api_error", message: "Provider type mismatch for this endpoint" } },
+    }),
+    upstreamConnectionFailed: () => ({
+        statusCode: 502,
+        body: { type: "error", error: { type: "upstream_error", message: "Failed to connect to upstream service" } },
+    }),
+};
+const anthropicProxyRaw = (app, opts, done) => {
+    const { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
+    app.post(MESSAGES_PATH, async (request, reply) => {
+        const deps = { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
+        return handleProxyPost(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
+    });
+    done();
+};
+export const anthropicProxy = fp(anthropicProxyRaw, { name: "anthropic-proxy" });

package/dist/proxy/mapping-resolver.d.ts

@@ -0,0 +1,3 @@
+import Database from "better-sqlite3";
+import type { Target, ResolveContext } from "./strategy/types.js";
+export declare function resolveMapping(db: Database.Database, clientModel: string, context: ResolveContext): Target | null;