ai-world-sdk 1.0.0

package/dist/__tests__/example.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test file for Langchain SDK
+ * Tests Gemini model functionality
+ */
+export {};

package/dist/__tests__/example.test.js

@@ -0,0 +1,533 @@
+"use strict";
+/**
+ * Test file for Langchain SDK
+ * Tests Gemini model functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = __importStar(require("dotenv"));
+const index_1 = require("../index");
+// Load environment variables from .env file
+dotenv.config();
+index_1.sdkConfig.setBaseUrl("http://localhost:8000");
+index_1.sdkConfig.setToken(process.env.AUTH_TOKEN || process.env.TOKEN || "");
+function extractTextFromChunk(chunk) {
+    if (typeof chunk.content === "string") {
+        return chunk.content;
+    }
+    else if (Array.isArray(chunk.content)) {
+        return chunk.content.map(item => typeof item === "string" ? item : item?.text || "").join("");
+    }
+    return "";
+}
+describe("Langchain SDK Tests", () => {
+    const token = process.env.AUTH_TOKEN || process.env.TOKEN;
+    beforeAll(() => {
+        if (!token) {
+            console.warn("⚠️  警告: 未设置 AUTH_TOKEN 或 TOKEN 环境变量，测试可能会失败");
+            console.warn("   请在项目根目录创建 .env 文件，添加: AUTH_TOKEN=your_jwt_token");
+        }
+    });
+    test("ChatGoogleGenerativeAI - 非流式调用", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+        });
+        const response = await gemini.invoke([
+            new index_1.HumanMessage("你好，请用一句话介绍人工智能。"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        expect(typeof response.content).toBe("string");
+        console.log("✅ 非流式测试成功");
+        console.log("AI:", response.content);
+    }, 30000);
+    test("ChatGoogleGenerativeAI - 流式调用", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+        });
+        let fullText = "";
+        for await (const chunk of gemini.stream([
+            new index_1.HumanMessage("请用一句话介绍人工智能，然后解释它的重要性。"),
+        ])) {
+            // chunk 是 AIMessageChunk 对象，提取 content
+            fullText += extractTextFromChunk(chunk);
+            console.log("AI stream chunk:", chunk);
+            console.log("AI stream text:", fullText);
+        }
+        expect(fullText.length).toBeGreaterThan(0);
+        console.log("✅ 流式测试成功");
+        console.log(`完整回复长度: ${fullText.length} 字符`);
+    }, 30000);
+    test("createChatModel 工厂函数", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const model = (0, index_1.createChatModel)("gemini-2.0-flash-exp-image-generation", {
+            temperature: 0.7,
+        });
+        const response = await model.invoke([
+            new index_1.SystemMessage("You are a helpful assistant."),
+            new index_1.HumanMessage("What is the capital of France?"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        expect(typeof response.content).toBe("string");
+        console.log("✅ 工厂函数测试成功");
+        console.log("AI:", response.content);
+    }, 30000);
+    test("BaseChatModel - bind 方法", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.5,
+        });
+        // 使用 bind 方法绑定新的参数
+        const boundModel = gemini.bind({ temperature: 0.9 });
+        const response = await boundModel.invoke([
+            new index_1.HumanMessage("用一句话介绍人工智能。"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        console.log("✅ bind 方法测试成功");
+        console.log("AI:", response.content);
+    }, 30000);
+    test("BaseChatModel - batch 方法", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+        });
+        // 批量调用
+        const responses = await gemini.batch([
+            [new index_1.HumanMessage("什么是人工智能？")],
+            [new index_1.HumanMessage("什么是机器学习？")],
+            [new index_1.HumanMessage("什么是深度学习？")],
+        ]);
+        expect(responses).toBeDefined();
+        expect(Array.isArray(responses)).toBe(true);
+        expect(responses.length).toBe(3);
+        responses.forEach((response) => {
+            expect(response).toBeDefined();
+            expect(response.content).toBeDefined();
+        });
+        console.log("✅ batch 方法测试成功");
+        console.log(`批量响应数量: ${responses.length}`);
+    }, 30000);
+    test("ChatGoogleGenerativeAI - aihubmix.com no stream", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            baseUrl: "http://localhost:8000",
+            token: token || "",
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+            headers: {
+                "X-Base-Url": "https://aihubmix.com",
+            },
+        });
+        const response = await gemini.invoke([
+            new index_1.HumanMessage("aihubmix.com是做什么的"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        expect(typeof response.content).toBe("string");
+        console.log("✅ aihubmix.com no stream 测试成功");
+        console.log("AI:", response.content);
+    }, 30000);
+    test("ChatGoogleGenerativeAI - aihubmix.com stream", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            baseUrl: "http://localhost:8000",
+            token: token || "",
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+            headers: {
+                "X-Base-Url": "https://aihubmix.com",
+            },
+        });
+        let fullText = "";
+        for await (const chunk of gemini.stream([
+            new index_1.HumanMessage("aihubmix.com是做什么的"),
+        ])) {
+            fullText += extractTextFromChunk(chunk);
+            console.log("AI stream chunk:", chunk);
+            console.log("AI stream text:", fullText);
+        }
+        expect(fullText.length).toBeGreaterThan(0);
+        console.log("✅ aihubmix.com stream 测试成功");
+        console.log("AI:", fullText);
+        console.log(`完整回复长度: ${fullText.length} 字符`);
+    }, 30000);
+    test("ChatGoogleGenerativeAI - Google 图像生成", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            modelName: "gemini-2.0-flash-exp-image-generation",
+            temperature: 0.7,
+        });
+        const response = await gemini.invoke([
+            new index_1.HumanMessage("请生成一张展示人工智能概念的图片"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        // 图像生成响应可能包含文本和图像数据
+        // 检查响应内容（可能是字符串、数组或包含图像的对象）
+        const content = response.content;
+        if (typeof content === "string") {
+            console.log("✅ Google 图像生成测试成功（文本响应）");
+            console.log("AI:", content);
+        }
+        else if (Array.isArray(content)) {
+            // 多模态响应，可能包含图像
+            const hasImage = content.some((item) => item?.type === "image_url" ||
+                item?.image_url ||
+                (typeof item === "string" && item.startsWith("data:image")));
+            console.log("✅ Google 图像生成测试成功（多模态响应）");
+            console.log("响应类型: 数组，包含图像:", hasImage);
+            console.log("响应内容:", JSON.stringify(content, null, 2));
+        }
+        else {
+            console.log("✅ Google 图像生成测试成功（其他格式）");
+            console.log("响应内容:", content);
+        }
+    }, 60000);
+    test("ChatGoogleGenerativeAI - aihubmix.com 图像生成", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            baseUrl: "http://localhost:8000",
+            token: token || "",
+            modelName: "gemini-3-pro-image-preview",
+            temperature: 0.7,
+            headers: {
+                "X-Base-Url": "https://aihubmix.com",
+            },
+        });
+        const response = await gemini.invoke([
+            new index_1.HumanMessage("请生成一张展示人工智能概念的图片"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        // 图像生成响应可能包含文本和图像数据
+        // 检查响应内容（可能是字符串、数组或包含图像的对象）
+        const content = response.content;
+        if (typeof content === "string") {
+            console.log("✅ aihubmix.com 图像生成测试成功（文本响应）");
+            console.log("AI:", content);
+        }
+        else if (Array.isArray(content)) {
+            // 多模态响应，可能包含图像
+            const hasImage = content.some((item) => item?.type === "image_url" ||
+                item?.image_url ||
+                (typeof item === "string" && item.startsWith("data:image")));
+            console.log("✅ aihubmix.com 图像生成测试成功（多模态响应）");
+            console.log("响应类型: 数组，包含图像:", hasImage);
+            console.log("响应内容:", JSON.stringify(content, null, 2));
+        }
+        else {
+            console.log("✅ aihubmix.com 图像生成测试成功（其他格式）");
+            console.log("响应内容:", content);
+        }
+    }, 60000);
+    test("ChatGoogleGenerativeAI - seedream 图像生成", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const gemini = new index_1.ChatGoogleGenerativeAI({
+            baseUrl: "http://localhost:8000",
+            token: token || "",
+            modelName: "doubao-seedream-4-5-251128",
+            temperature: 0.7,
+            headers: {
+                "X-Base-Url": "https://ark.cn-beijing.volces.com/api/v3/images/generations",
+            },
+        });
+        const response = await gemini.invoke([
+            new index_1.HumanMessage("请生成一张展示人工智能概念的图片"),
+        ]);
+        expect(response).toBeDefined();
+        expect(response.content).toBeDefined();
+        // 图像生成响应可能包含文本和图像数据
+        // 检查响应内容（可能是字符串、数组或包含图像的对象）
+        const content = response.content;
+        if (typeof content === "string") {
+            console.log("✅ aihubmix.com 图像生成测试成功（文本响应）");
+            console.log("AI:", content);
+        }
+        else if (Array.isArray(content)) {
+            // 多模态响应，可能包含图像
+            const hasImage = content.some((item) => item?.type === "image_url" ||
+                item?.image_url ||
+                (typeof item === "string" && item.startsWith("data:image")));
+            console.log("✅ aihubmix.com 图像生成测试成功（多模态响应）");
+            console.log("响应类型: 数组，包含图像:", hasImage);
+            console.log("响应内容:", JSON.stringify(content, null, 2));
+        }
+        else {
+            console.log("✅ aihubmix.com 图像生成测试成功（其他格式）");
+            console.log("响应内容:", content);
+        }
+    }, 60000);
+    test("ImageGenerationClient - 基础图像生成", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const imageClient = new index_1.ImageGenerationClient({});
+        const result = await imageClient.generate({
+            prompt: "充满活力的特写编辑肖像，模特眼神犀利，头戴雕塑感帽子，色彩拼接丰富，眼部焦点锐利，景深较浅，具有Vogue杂志封面的美学风格，采用中画幅拍摄，工作室灯光效果强烈。",
+            model: "doubao-seedream-4-5-251128",
+            size: "2K",
+            watermark: false,
+            n: 1,
+        });
+        expect(result).toBeDefined();
+        // 检查 OpenAI 标准格式：created 和 data
+        expect(result.created).toBeDefined();
+        expect(typeof result.created).toBe("number");
+        expect(result.data).toBeDefined();
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data.length).toBeGreaterThan(0);
+        // 检查每个图像数据项
+        result.data.forEach((item) => {
+            expect(item).toBeDefined();
+            // 应该包含 url 或 b64_json
+            expect(item.url || item.b64_json).toBeDefined();
+        });
+        console.log("✅ 基础图像生成测试成功");
+        console.log(`生成图像数量: ${result.data.length}`);
+        console.log("图像 URL:", result.data[0]?.url || "Base64 编码");
+        console.log("创建时间:", new Date(result.created * 1000).toISOString());
+    }, 120000);
+    test("ImageGenerationClient - 多图像生成 (n=2)", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const imageClient = new index_1.ImageGenerationClient({});
+        const result = await imageClient.generate({
+            prompt: "A beautiful sunset over the ocean with vibrant colors",
+            model: "doubao-seedream-4-5-251128",
+            size: "2K",
+            n: 2,
+        });
+        expect(result).toBeDefined();
+        expect(result.data).toBeDefined();
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data.length).toBe(2);
+        console.log("✅ 多图像生成测试成功");
+        console.log(`生成图像数量: ${result.data.length}`);
+        result.data.forEach((item, index) => {
+            console.log(`图像 ${index + 1}:`, item.url || "Base64 编码");
+        });
+    }, 120000);
+    test("ImageGenerationClient - 不同尺寸测试", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const imageClient = new index_1.ImageGenerationClient({});
+        const sizes = ["1K", "2K", "4K"];
+        for (const size of sizes) {
+            const result = await imageClient.generate({
+                prompt: "A futuristic city skyline at sunset",
+                model: "doubao-seedream-4-5-251128",
+                size: size,
+                n: 1,
+            });
+            expect(result).toBeDefined();
+            expect(result.data).toBeDefined();
+            expect(result.data.length).toBeGreaterThan(0);
+            console.log(`✅ 尺寸 ${size} 测试成功`);
+        }
+    }, 180000);
+    test("VideoGenerationClient - 创建视频生成任务（文本）", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const videoClient = new index_1.VideoGenerationClient({});
+        const task = await videoClient.create({
+            prompt: "A beautiful sunset over the ocean with waves crashing on the shore",
+            model: "doubao-seedance-1-0-pro-fast-251015",
+            duration: 5,
+            aspect_ratio: "16:9",
+            resolution: "720p",
+        });
+        expect(task).toBeDefined();
+        expect(task.id).toBeDefined();
+        expect(typeof task.id).toBe("string");
+        console.log("✅ 视频生成任务创建成功");
+        console.log("任务 ID:", task.id);
+    }, 30000);
+    test("VideoGenerationClient - 创建视频生成任务（图像）", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const videoClient = new index_1.VideoGenerationClient({});
+        const task = await videoClient.create({
+            image_url: "https://example.com/image.jpg",
+            model: "doubao-seedance-1-0-pro-fast-251015",
+            duration: 5,
+        });
+        expect(task).toBeDefined();
+        expect(task.id).toBeDefined();
+        expect(typeof task.id).toBe("string");
+        console.log("✅ 图像生成视频任务创建成功");
+        console.log("任务 ID:", task.id);
+    }, 30000);
+    test("VideoGenerationClient - 查询视频生成任务", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const videoClient = new index_1.VideoGenerationClient({
+            baseUrl: "http://localhost:8000",
+            token: token || "",
+        });
+        // 先创建一个任务
+        const createTask = await videoClient.create({
+            prompt: "A serene mountain landscape with a lake",
+            model: "doubao-seedance-1-0-pro-fast-251015",
+            duration: 3,
+        });
+        expect(createTask.id).toBeDefined();
+        // 查询任务状态
+        const task = await videoClient.get(createTask.id);
+        expect(task).toBeDefined();
+        expect(task.id).toBe(createTask.id);
+        expect(task.model).toBeDefined();
+        expect(task.status).toBeDefined();
+        expect(["queued", "running", "succeeded", "failed", "cancelled"]).toContain(task.status);
+        expect(task.created_at).toBeDefined();
+        expect(typeof task.created_at).toBe("number");
+        console.log("✅ 视频任务查询成功");
+        console.log("任务状态:", task.status);
+        console.log("任务模型:", task.model);
+        if (task.content?.video_url) {
+            console.log("视频 URL:", task.content.video_url);
+        }
+    }, 30000);
+    test("VideoGenerationClient - 轮询视频生成任务", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const videoClient = new index_1.VideoGenerationClient({});
+        // 创建任务
+        const createTask = await videoClient.create({
+            prompt: "A short video of a cat playing",
+            model: "doubao-seedance-1-0-pro-fast-251015",
+            duration: 3,
+        });
+        expect(createTask.id).toBeDefined();
+        console.log("createTask:", createTask.id);
+        // 轮询任务（使用较短的超时时间用于测试）
+        try {
+            const result = await videoClient.poll(createTask.id, {
+                interval: 2000, // 2秒轮询一次
+                timeout: 60000, // 60秒超时
+            });
+            expect(result).toBeDefined();
+            expect(["succeeded", "failed", "cancelled"]).toContain(result.status);
+            console.log("✅ 视频任务轮询完成");
+            console.log("最终状态:", result.status);
+            if (result.status === "succeeded" && result.content?.video_url) {
+                console.log("视频 URL:", result.content.video_url);
+            }
+            else if (result.error) {
+                console.log("错误信息:", result.error.message);
+            }
+        }
+        catch (error) {
+            // 如果超时，这是正常的（视频生成需要时间）
+            if (error.message?.includes("timeout")) {
+                console.log("⏭️  轮询超时（正常，视频生成需要较长时间）");
+            }
+            else {
+                throw error;
+            }
+        }
+    }, 120000);
+    test("VideoGenerationClient - 直接提供 content", async () => {
+        if (!token) {
+            console.log("⏭️  跳过测试: 未设置 AUTH_TOKEN");
+            return;
+        }
+        const videoClient = new index_1.VideoGenerationClient({});
+        const task = await videoClient.create({
+            model: "doubao-seedance-1-0-pro-fast-251015",
+            content: [
+                {
+                    type: "text",
+                    text: "A beautiful sunset over the ocean --ratio 16:9 --duration 5",
+                },
+            ],
+            return_last_frame: true,
+        });
+        expect(task).toBeDefined();
+        expect(task.id).toBeDefined();
+        console.log("✅ 使用 content 参数创建任务成功");
+        console.log("任务 ID:", task.id);
+    }, 30000);
+});

package/dist/base.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Base chat model class
+ * Similar to LangChain.js BaseChatModel
+ */
+import { BaseMessage, AIMessage, AIMessageChunk } from "./messages";
+export interface BaseChatModelParams {
+    baseUrl?: string;
+    token?: string;
+    headers?: Record<string, string>;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    modelName?: string;
+    provider?: string;
+    apiKey?: string;
+}
+export interface ChatResult {
+    content: string;
+    role: string;
+}
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, any>;
+    };
+}
+export interface BindOptions {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    tools?: ToolDefinition[];
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+}
+export declare abstract class BaseChatModel {
+    protected baseUrl: string;
+    protected headers: Record<string, string>;
+    protected temperature: number;
+    protected maxTokens?: number;
+    protected topP?: number;
+    protected modelName: string;
+    protected boundOptions?: BindOptions;
+    protected provider?: string;
+    protected apiKey?: string;
+    constructor(config: {
+        baseUrl?: string;
+        token?: string;
+        headers?: Record<string, string>;
+        temperature?: number;
+        maxTokens?: number;
+        topP?: number;
+        modelName: string;
+        provider?: string;
+        apiKey?: string;
+    });
+    /**
+     * Invoke the model with messages (non-streaming)
+     * 遵循标准 LangChain API
+     */
+    invoke(messages: BaseMessage[]): Promise<AIMessage>;
+    /**
+     * Stream the model with messages
+     * 遵循标准 LangChain API，返回 AIMessageChunk
+     */
+    stream(messages: BaseMessage[]): AsyncGenerator<AIMessageChunk, void, unknown>;
+    /**
+     * Batch invoke multiple message sets
+     * 遵循标准 LangChain API
+     */
+    batch(messagesList: BaseMessage[][]): Promise<AIMessage[]>;
+    /**
+     * Bind options to the model (temperature, maxTokens, tools, etc.)
+     * Returns a new model instance with bound options
+     * Similar to LangChain.js bind method
+     */
+    bind(options: BindOptions): BaseChatModel;
+    /**
+     * Bind tools to the model
+     * Similar to LangChain.js bindTools method
+     */
+    bindTools(tools: ToolDefinition[]): BaseChatModel;
+    /**
+     * Merge bound options with provided options
+     */
+    protected _mergeOptions(options: Partial<BindOptions>): BindOptions;
+    /**
+     * Get the current model name
+     */
+    getModelName(): string;
+}