karin-plugin-kkk 1.1.4 → 1.1.7-pr51.16aebd4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [1.1.6](https://github.com/ikenxuan/karin-plugin-kkk/compare/v1.1.5...v1.1.6) (2025-03-24)
+
+
+### Bug Fixes
+
+* ci ([149f99c](https://github.com/ikenxuan/karin-plugin-kkk/commit/149f99cb89af18da99b18fc13793fcbb5ebc75f3))
+
+## [1.1.5](https://github.com/ikenxuan/karin-plugin-kkk/compare/v1.1.4...v1.1.5) (2025-03-24)
+
+
+### Bug Fixes
+
+* 优化前端配置显示 ([b64efa6](https://github.com/ikenxuan/karin-plugin-kkk/commit/b64efa65a82b191bd59dc8b82871eb5250a0f54a))
+* 移除一些过时内容 ([65d2a0a](https://github.com/ikenxuan/karin-plugin-kkk/commit/65d2a0a0d55ffaf3ecd87acbdfcd4c89ba0a5e1b))
+* 评论解析错误 ([d08c76e](https://github.com/ikenxuan/karin-plugin-kkk/commit/d08c76e363f7701df60c9e12d26fbbe0518a365d))
+
 ## [1.1.4](https://github.com/ikenxuan/karin-plugin-kkk/compare/v1.1.3...v1.1.4) (2025-03-01)
 
 

package/README.md

@@ -1,12 +1,23 @@
-![karin-plugin-kkk](https://socialify.git.ci/ikenxuan/karin-plugin-kkk/image?description=1&font=Source+Code+Pro&forks=1&issues=1&language=1&name=1&owner=1&pattern=Floating+Cogs&pulls=1&stargazers=1&theme=Auto)
-
 # karin-plugin-kkk
-
 🦄 **_Karin 的「抖音」「B站」「快手」视频解析/动态推送插件_**
 
+PS: 快手暂不支持推送
+
 ## ⬇️ 安装
 
-* 使用编译产物 **`build 分支`**（非常推荐）
+* 使用 **`包管理器`** 安装（非常推荐）
+   <details>
+   <summary>点击展开</summary>
+
+   在 **Karin 根目录** 下运行
+   ```sh
+   pnpm add karin-plugin-kkk@latest -w
+   ```
+   </details>
+
+<br />
+
+* 克隆编译产物 **`build 分支`**（比较推荐）
    <details>
    <summary>点击展开</summary>
 
@@ -34,15 +45,7 @@
 
    </details>
 
-* 使用 **`包管理器`** 安装（非常推荐）
-   <details>
-   <summary>点击展开</summary>
-
-   在 **Karin 根目录** 下运行
-   ```sh
-   pnpm add karin-plugin-kkk@latest -w
-   ```
-   </details>
+<br />
 
 * 使用 Release **`发行版`**（不推荐）
     <details>

package/lib/apps/push.js

@@ -36,10 +36,10 @@ export const setbiliPush = karin.command(/^#设置[bB]站推送(?:[Uu][Ii][Dd]:)
     return true;
 }, { name: 'kkk-推送功能-设置', event: 'message.group', perm: Config.bilibili.push.permission, dsbAdapter: ['qqbot'] });
 export const bilibiliPushList = karin.command(/^#?[bB]站推送列表$/, async (e) => {
-    await new Bilibilipush(e).renderPushList(Config.pushlist.bilibili);
+    await new Bilibilipush(e).renderPushList();
 }, { name: 'kkk-推送功能-列表', event: 'message.group' });
 export const douyinPushList = karin.command(/^#?抖音推送列表$/, async (e) => {
-    await new DouYinpush(e).renderPushList(Config.pushlist.douyin);
+    await new DouYinpush(e).renderPushList();
 }, { name: 'kkk-推送功能-列表', event: 'message.group' });
 export const changeBotID = karin.command(/^#kkk设置推送机器人/, async (e) => {
     const newDouyinlist = Config.pushlist.douyin.map(item => {

package/lib/module/db/bilibili.d.ts

@@ -0,0 +1,121 @@
+import { Model } from 'sequelize';
+import { bilibiliPushItem } from '../../types/config/pushlist.js';
+type GroupUserSubscriptionAttributes = {
+    id?: number;
+    /** 群号 */
+    groupId: string;
+    /** UP主UID */
+    host_mid: number;
+};
+/** Bots表 - 存储机器人信息 */
+declare const Bot: import("sequelize").ModelCtor<Model<any, any>>;
+/** Groups表 - 存储群组信息 */
+declare const Group: import("sequelize").ModelCtor<Model<any, any>>;
+/** BilibiliUsers表 - 存储B站用户信息 */
+declare const BilibiliUser: import("sequelize").ModelCtor<Model<any, any>>;
+/** GroupUserSubscriptions表 - 存储群组订阅的B站用户关系 */
+declare const GroupUserSubscription: import("sequelize").ModelCtor<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>>;
+/** DynamicCache表 - 存储已推送的动态ID */
+declare const DynamicCache: import("sequelize").ModelCtor<Model<any, any>>;
+/** 数据库操作类 */
+export declare class BilibiliDBBase {
+    /**
+     * 获取或创建机器人记录
+     * @param botId 机器人ID
+     */
+    getOrCreateBot(botId: string): Promise<Model<any, any>>;
+    /**
+     * 获取或创建群组记录
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     */
+    getOrCreateGroup(groupId: string, botId: string): Promise<Model<any, any>>;
+    /**
+     * 获取或创建B站用户记录
+     * @param host_mid B站用户UID
+     * @param remark UP主昵称
+     * @param avatar_img 头像URL
+     */
+    getOrCreateBilibiliUser(host_mid: number, remark?: string): Promise<Model<any, any>>;
+    /**
+     * 订阅B站用户
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     * @param host_mid B站用户UID
+     * @param remark UP主昵称
+     */
+    subscribeBilibiliUser(groupId: string, botId: string, host_mid: number, remark?: string): Promise<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>>;
+    /**
+     * 取消订阅B站用户
+     * @param groupId 群组ID
+     * @param host_mid B站用户UID
+     */
+    unsubscribeBilibiliUser(groupId: string, host_mid: number): Promise<boolean>;
+    /**
+     * 添加动态缓存
+     * @param dynamic_id 动态ID
+     * @param host_mid B站用户UID
+     * @param groupId 群组ID
+     * @param dynamic_type 动态类型
+     */
+    addDynamicCache(dynamic_id: string, host_mid: number, groupId: string, dynamic_type: string): Promise<Model<any, any>>;
+    /**
+     * 检查动态是否已推送
+     * @param dynamic_id 动态ID
+     * @param host_mid B站用户UID
+     * @param groupId 群组ID
+     */
+    isDynamicPushed(dynamic_id: string, host_mid: number, groupId: string): Promise<boolean>;
+    /**
+     * 获取机器人管理的所有群组
+     * @param botId 机器人ID
+     */
+    getBotGroups(botId: string): Promise<Model<any, any>[]>;
+    /**
+     * 获取群组订阅的所有B站用户
+     * @param groupId 群组ID
+     */
+    getGroupSubscriptions(groupId: string): Promise<Model<GroupUserSubscriptionAttributes>[]>;
+    /**
+     * 获取B站用户的所有订阅群组
+     * @param host_mid B站用户UID
+     */
+    getUserSubscribedGroups(host_mid: number): Promise<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>[]>;
+    /**
+     * 获取群组的动态缓存
+     * @param groupId 群组ID
+     * @param host_mid 可选的B站用户UID过滤
+     */
+    getGroupDynamicCache(groupId: string, host_mid?: number): Promise<Model<any, any>[]>;
+    /**
+   * 检查群组是否已订阅B站用户
+   * @param host_mid B站用户UID
+   * @param groupId 群组ID
+   */
+    isSubscribed(host_mid: number, groupId: string): Promise<boolean>;
+    /**
+     * 迁移旧数据到新数据库结构
+     * @param oldData 旧的数据结构
+     */
+    migrateOldData(oldData: any): Promise<void>;
+    /**
+     * 批量同步配置文件中的订阅到数据库
+     * @param configItems 配置文件中的订阅项
+     */
+    syncConfigSubscriptions(configItems: bilibiliPushItem[]): Promise<void>;
+}
+export declare const bilibiliDB: BilibiliDBBase;
+export { BilibiliUser, Bot, DynamicCache, Group, GroupUserSubscription };
+/** B站数据库模型集合 */
+export declare const bilibiliModels: {
+    /** BilibiliUsers表 - 存储B站用户信息 */
+    BilibiliUser: import("sequelize").ModelCtor<Model<any, any>>;
+    /** Bots表 - 存储机器人信息 */
+    Bot: import("sequelize").ModelCtor<Model<any, any>>;
+    /** DynamicCache表 - 存储已推送的动态ID */
+    DynamicCache: import("sequelize").ModelCtor<Model<any, any>>;
+    /** Groups表 - 存储群组信息 */
+    Group: import("sequelize").ModelCtor<Model<any, any>>;
+    /** GroupUserSubscriptions表 - 存储群组订阅的B站用户关系 */
+    GroupUserSubscription: import("sequelize").ModelCtor<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>>;
+};

package/lib/module/db/bilibili.js

@@ -0,0 +1,353 @@
+import { join } from 'node:path';
+import { basePath } from 'node-karin';
+import { DataTypes, Sequelize } from 'sequelize';
+import { Version } from '../utils/index.js';
+/** 创建 Sequelize 实例，需要传入配置对象。 */
+const sequelize = new Sequelize({
+    dialect: 'sqlite',
+    storage: join(`${basePath}/${Version.pluginName}/data`, 'bilibili.db'),
+    logging: false
+});
+/** 测试数据库连接是否成功 */
+await sequelize.authenticate();
+// 定义模型
+/** Bots表 - 存储机器人信息 */
+const Bot = sequelize.define('Bot', {
+    id: {
+        type: DataTypes.STRING,
+        primaryKey: true,
+        comment: '机器人ID'
+    }
+}, {
+    timestamps: true
+});
+/** Groups表 - 存储群组信息 */
+const Group = sequelize.define('Group', {
+    id: {
+        type: DataTypes.STRING,
+        primaryKey: true,
+        comment: '群组ID'
+    },
+    botId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '所属机器人ID',
+        references: {
+            model: 'Bots',
+            key: 'id'
+        }
+    }
+}, {
+    timestamps: true
+});
+/** BilibiliUsers表 - 存储B站用户信息 */
+const BilibiliUser = sequelize.define('BilibiliUser', {
+    host_mid: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        comment: 'B站用户UID'
+    },
+    remark: {
+        type: DataTypes.STRING,
+        comment: 'B站用户昵称'
+    },
+    avatar_img: {
+        type: DataTypes.STRING,
+        comment: '头像URL'
+    }
+}, {
+    timestamps: true
+});
+/** GroupUserSubscriptions表 - 存储群组订阅的B站用户关系 */
+const GroupUserSubscription = sequelize.define('GroupUserSubscription', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        comment: '订阅ID'
+    },
+    groupId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '群组ID',
+        references: {
+            model: 'Groups',
+            key: 'id'
+        }
+    },
+    host_mid: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        comment: 'B站用户UID',
+        references: {
+            model: 'BilibiliUsers',
+            key: 'host_mid'
+        }
+    }
+}, {
+    timestamps: true
+});
+/** DynamicCache表 - 存储已推送的动态ID */
+const DynamicCache = sequelize.define('DynamicCache', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        comment: '缓存ID'
+    },
+    dynamic_id: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '动态ID'
+    },
+    host_mid: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        comment: 'B站用户UID',
+        references: {
+            model: 'BilibiliUsers',
+            key: 'host_mid'
+        }
+    },
+    groupId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '群组ID',
+        references: {
+            model: 'Groups',
+            key: 'id'
+        }
+    },
+    dynamic_type: {
+        type: DataTypes.STRING,
+        comment: '动态类型'
+    }
+}, {
+    timestamps: true
+});
+// 建立关联关系
+Bot.hasMany(Group, { foreignKey: 'botId' });
+Group.belongsTo(Bot, { foreignKey: 'botId' });
+Group.belongsToMany(BilibiliUser, { through: GroupUserSubscription, foreignKey: 'groupId' });
+BilibiliUser.belongsToMany(Group, { through: GroupUserSubscription, foreignKey: 'host_mid' });
+BilibiliUser.hasMany(DynamicCache, { foreignKey: 'host_mid' });
+DynamicCache.belongsTo(BilibiliUser, { foreignKey: 'host_mid' });
+Group.hasMany(DynamicCache, { foreignKey: 'groupId' });
+DynamicCache.belongsTo(Group, { foreignKey: 'groupId' });
+/** 数据库操作类 */
+export class BilibiliDBBase {
+    /**
+     * 获取或创建机器人记录
+     * @param botId 机器人ID
+     */
+    async getOrCreateBot(botId) {
+        const [bot] = await Bot.findOrCreate({
+            where: { id: botId }
+        });
+        return bot;
+    }
+    /**
+     * 获取或创建群组记录
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     */
+    async getOrCreateGroup(groupId, botId) {
+        await this.getOrCreateBot(botId);
+        const [group] = await Group.findOrCreate({
+            where: { id: groupId, botId }
+        });
+        return group;
+    }
+    /**
+     * 获取或创建B站用户记录
+     * @param host_mid B站用户UID
+     * @param remark UP主昵称
+     * @param avatar_img 头像URL
+     */
+    async getOrCreateBilibiliUser(host_mid, remark = '') {
+        const [user] = await BilibiliUser.findOrCreate({
+            where: { host_mid },
+            defaults: { remark }
+        });
+        return user;
+    }
+    /**
+     * 订阅B站用户
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     * @param host_mid B站用户UID
+     * @param remark UP主昵称
+     */
+    async subscribeBilibiliUser(groupId, botId, host_mid, remark = '') {
+        await this.getOrCreateGroup(groupId, botId);
+        await this.getOrCreateBilibiliUser(host_mid, remark);
+        const [subscription] = await GroupUserSubscription.findOrCreate({
+            where: { groupId, host_mid }
+        });
+        return subscription;
+    }
+    /**
+     * 取消订阅B站用户
+     * @param groupId 群组ID
+     * @param host_mid B站用户UID
+     */
+    async unsubscribeBilibiliUser(groupId, host_mid) {
+        const result = await GroupUserSubscription.destroy({
+            where: { groupId, host_mid }
+        });
+        // 清除相关的动态缓存
+        await DynamicCache.destroy({
+            where: { groupId, host_mid }
+        });
+        return result > 0;
+    }
+    /**
+     * 添加动态缓存
+     * @param dynamic_id 动态ID
+     * @param host_mid B站用户UID
+     * @param groupId 群组ID
+     * @param dynamic_type 动态类型
+     */
+    async addDynamicCache(dynamic_id, host_mid, groupId, dynamic_type) {
+        const [cache] = await DynamicCache.findOrCreate({
+            where: { dynamic_id, host_mid, groupId },
+            defaults: { dynamic_type }
+        });
+        return cache;
+    }
+    /**
+     * 检查动态是否已推送
+     * @param dynamic_id 动态ID
+     * @param host_mid B站用户UID
+     * @param groupId 群组ID
+     */
+    async isDynamicPushed(dynamic_id, host_mid, groupId) {
+        const count = await DynamicCache.count({
+            where: { dynamic_id, host_mid, groupId }
+        });
+        return count > 0;
+    }
+    /**
+     * 获取机器人管理的所有群组
+     * @param botId 机器人ID
+     */
+    async getBotGroups(botId) {
+        return await Group.findAll({
+            where: { botId }
+        });
+    }
+    /**
+     * 获取群组订阅的所有B站用户
+     * @param groupId 群组ID
+     */
+    async getGroupSubscriptions(groupId) {
+        return await GroupUserSubscription.findAll({
+            where: { groupId }
+        });
+    }
+    /**
+     * 获取B站用户的所有订阅群组
+     * @param host_mid B站用户UID
+     */
+    async getUserSubscribedGroups(host_mid) {
+        return await GroupUserSubscription.findAll({
+            where: { host_mid },
+            include: [Group]
+        });
+    }
+    /**
+     * 获取群组的动态缓存
+     * @param groupId 群组ID
+     * @param host_mid 可选的B站用户UID过滤
+     */
+    async getGroupDynamicCache(groupId, host_mid) {
+        const where = { groupId };
+        if (host_mid)
+            where.host_mid = host_mid;
+        return await DynamicCache.findAll({
+            where,
+            order: [['createdAt', 'DESC']]
+        });
+    }
+    /**
+   * 检查群组是否已订阅B站用户
+   * @param host_mid B站用户UID
+   * @param groupId 群组ID
+   */
+    async isSubscribed(host_mid, groupId) {
+        const count = await GroupUserSubscription.count({
+            where: { host_mid, groupId }
+        });
+        return count > 0;
+    }
+    /**
+     * 迁移旧数据到新数据库结构
+     * @param oldData 旧的数据结构
+     */
+    async migrateOldData(oldData) {
+        if (!oldData || !oldData.bilibili)
+            return;
+        for (const groupIdWithBotId in oldData.bilibili) {
+            const [groupId, botId] = groupIdWithBotId.split(':');
+            if (!groupId || !botId)
+                continue;
+            const groupData = oldData.bilibili[groupIdWithBotId];
+            for (const hostMidKey in groupData) {
+                const userData = groupData[hostMidKey];
+                const host_mid = userData.host_mid;
+                const remark = userData.remark;
+                const dynamic_idlist = userData.dynamic_idlist || [];
+                const dynamic_type = userData.dynamic_type;
+                // 创建订阅关系
+                await this.subscribeBilibiliUser(groupId, botId, host_mid, remark);
+                // 添加动态缓存
+                for (const dynamic_id of dynamic_idlist) {
+                    await this.addDynamicCache(dynamic_id, host_mid, groupId, dynamic_type);
+                }
+            }
+        }
+    }
+    /**
+     * 批量同步配置文件中的订阅到数据库
+     * @param configItems 配置文件中的订阅项
+     */
+    async syncConfigSubscriptions(configItems) {
+        if (!configItems || configItems.length === 0)
+            return;
+        for (const item of configItems) {
+            const host_mid = item.host_mid;
+            const remark = item.remark || '';
+            // 创建或更新B站用户记录
+            await this.getOrCreateBilibiliUser(host_mid, remark);
+            // 处理该UP主的所有群组订阅
+            for (const groupWithBot of item.group_id) {
+                const [groupId, botId] = groupWithBot.split(':');
+                if (!groupId || !botId)
+                    continue;
+                // 检查是否已订阅
+                const isSubscribed = await this.isSubscribed(host_mid, groupId);
+                // 如果未订阅，创建订阅关系
+                if (!isSubscribed) {
+                    await this.subscribeBilibiliUser(groupId, botId, host_mid, remark);
+                }
+            }
+        }
+    }
+}
+export const bilibiliDB = new BilibiliDBBase();
+// 同步数据库结构
+await sequelize.sync({ alter: true, force: false });
+export { BilibiliUser, Bot, DynamicCache, Group, GroupUserSubscription };
+/** B站数据库模型集合 */
+export const bilibiliModels = {
+    /** BilibiliUsers表 - 存储B站用户信息 */
+    BilibiliUser,
+    /** Bots表 - 存储机器人信息 */
+    Bot,
+    /** DynamicCache表 - 存储已推送的动态ID */
+    DynamicCache,
+    /** Groups表 - 存储群组信息 */
+    Group,
+    /** GroupUserSubscriptions表 - 存储群组订阅的B站用户关系 */
+    GroupUserSubscription
+};

package/lib/module/db/douyin.d.ts

@@ -0,0 +1,125 @@
+import { Model } from 'sequelize';
+import { douyinPushItem } from '../../types/config/pushlist.js';
+type GroupUserSubscriptionAttributes = {
+    id?: number;
+    /** 群号 */
+    groupId: string;
+    /** 抖音用户sec_uid */
+    sec_uid: string;
+};
+/** 数据库操作类 */
+export declare class DouyinDBBase {
+    /**
+     * 获取或创建机器人记录
+     * @param botId 机器人ID
+     */
+    getOrCreateBot(botId: string): Promise<Model<any, any>>;
+    /**
+     * 获取或创建群组记录
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     */
+    getOrCreateGroup(groupId: string, botId: string): Promise<Model<any, any>>;
+    /**
+     * 获取或创建抖音用户记录
+     * @param sec_uid 抖音用户sec_uid
+     * @param short_id 抖音号
+     * @param remark 用户昵称
+     */
+    getOrCreateDouyinUser(sec_uid: string, short_id?: string, remark?: string): Promise<Model<any, any>>;
+    /**
+     * 订阅抖音用户
+     * @param groupId 群组ID
+     * @param botId 机器人ID
+     * @param sec_uid 抖音用户sec_uid
+     * @param short_id 抖音号
+     * @param remark 用户昵称
+     */
+    subscribeDouyinUser(groupId: string, botId: string, sec_uid: string, short_id?: string, remark?: string): Promise<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>>;
+    /**
+     * 取消订阅抖音用户
+     * @param groupId 群组ID
+     * @param sec_uid 抖音用户sec_uid
+     */
+    unsubscribeDouyinUser(groupId: string, sec_uid: string): Promise<boolean>;
+    /**
+     * 添加作品缓存
+     * @param aweme_id 作品ID
+     * @param sec_uid 抖音用户sec_uid
+     * @param groupId 群组ID
+     */
+    addAwemeCache(aweme_id: string, sec_uid: string, groupId: string): Promise<Model<any, any>>;
+    /**
+     * 检查作品是否已推送
+     * @param aweme_id 作品ID
+     * @param sec_uid 抖音用户sec_uid
+     * @param groupId 群组ID
+     */
+    isAwemePushed(aweme_id: string, sec_uid: string, groupId: string): Promise<boolean>;
+    /**
+     * 获取机器人管理的所有群组
+     * @param botId 机器人ID
+     */
+    getBotGroups(botId: string): Promise<Model<any, any>[]>;
+    /**
+     * 获取群组订阅的所有抖音用户
+     * @param groupId 群组ID
+     */
+    getGroupSubscriptions(groupId: string): Promise<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>[]>;
+    /**
+     * 获取抖音用户的所有订阅群组
+     * @param sec_uid 抖音用户sec_uid
+     */
+    getUserSubscribedGroups(sec_uid: string): Promise<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>[]>;
+    /**
+     * 检查群组是否已订阅抖音用户
+     * @param sec_uid 抖音用户sec_uid
+     * @param groupId 群组ID
+     */
+    isSubscribed(sec_uid: string, groupId: string): Promise<boolean>;
+    /**
+     * 更新用户直播状态
+     * @param sec_uid 抖音用户sec_uid
+     * @param living 是否正在直播
+     */
+    updateLiveStatus(sec_uid: string, living: boolean): Promise<boolean>;
+    /**
+     * 获取用户直播状态
+     * @param sec_uid 抖音用户sec_uid
+     */
+    getLiveStatus(sec_uid: string): Promise<{
+        living: boolean;
+        live_msg_id: string;
+        live_start_time: number;
+    }>;
+    /**
+     * 批量同步配置文件中的订阅到数据库
+     * @param configItems 配置文件中的订阅项
+     */
+    syncConfigSubscriptions(configItems: douyinPushItem[]): Promise<void>;
+    /**
+     * 迁移旧数据到新数据库结构
+     * @param oldData 旧的数据结构
+     */
+    migrateOldData(oldData: any): Promise<void>;
+    /**
+     * 通过ID获取群组信息
+     * @param groupId 群组ID
+     */
+    getGroupById(groupId: string): Promise<Model<any, any> | null>;
+}
+export declare const douyinDB: DouyinDBBase;
+/** 抖音数据库模型集合 */
+export declare const DouyinModels: {
+    /** AwemeCache表 - 存储已推送的作品ID */
+    AwemeCache: import("sequelize").ModelCtor<Model<any, any>>;
+    /** Bots表 - 存储机器人信息 */
+    Bot: import("sequelize").ModelCtor<Model<any, any>>;
+    /** DouyinUsers表 - 存储抖音用户信息 */
+    DouyinUser: import("sequelize").ModelCtor<Model<any, any>>;
+    /** Groups表 - 存储群组信息 */
+    Group: import("sequelize").ModelCtor<Model<any, any>>;
+    /** GroupUserSubscriptions表 - 存储群组订阅的抖音用户关系 */
+    GroupUserSubscription: import("sequelize").ModelCtor<Model<GroupUserSubscriptionAttributes, GroupUserSubscriptionAttributes>>;
+};
+export {};