beatsaber-bot-core 0.2.0-rc.11 → 0.2.0-rc.13

package/dist/types/index.d.ts

@@ -1,45 +1,1031 @@
-import { ScheduleTaskCtx } from './schedules/interface.js';
-import { C as Command } from './index-Dagy_c8G.js';
-export { d as CmdAlias, a as CmdContext, b as CmdExecutor, c as CmdOption, E as Extend, O as OptionType, P as Platform, S as Services, p as parsePlatform } from './index-Dagy_c8G.js';
-import { Config } from './config.js';
-export { getScheduleTasks } from './schedules/index.js';
-export { botCommands } from './cmd/index.js';
-export { BeatleaderWSHandler } from './ws/beatleader.js';
-export { ScoresaberWSHandler } from './ws/scoresaber.js';
-export { BeatSaverWSHandler } from './ws/beatsaver.js';
-export { WSHandler } from './ws/handler.js';
-export { convertDiff, handleWSEventWithCache, sleep } from './utils/index.js';
-export { CFBrowserRendering, ImageRender, PuppeteerRendering, RemoteBrowserGetter, RenderConfig, getImageRender } from './infra/support/render/index.js';
-export { tran } from './infra/i18n/index.js';
-export { RelateAccount, RelateChannelInfo, Subscribe, SubscribeMember, UserPreference } from './interface/db/models.js';
-export { DB, SubDetailWithGroupRes, SubInfoRes, SubWithGroupRes } from './interface/db/index.js';
-export { Logger } from './interface/logger.js';
-export { BotService, Session } from './interface/bot.js';
-export { RenderOptions as PuppeteerOptions } from './infra/support/render/puppeteer.js';
-import './service/api/index.js';
-import './service/api/interfaces/scoresaber/item.js';
-import './service/api/interfaces/scoresaber/user.js';
-import './service/api/interfaces/beatleader/score.js';
-import './service/api/interfaces/beatleader/user.js';
-import './service/api/base/ssclient.js';
-import './infra/support/fetch/ofetch.js';
-import 'ofetch';
-import './service/api/interfaces/scoresaber/resp.js';
-import './service/api/interfaces/scoresaber/leaderboard.js';
-import './service/api/base/blclient.js';
-import './service/api/interfaces/index.js';
-import './service/api/interfaces/beatleader/req.js';
-import './service/api/base/aioclient.js';
-import './service/api/interfaces/aiosaber/index.js';
-import './service/api/base/bsclient.js';
-import './service/api/interfaces/beatsaver/bsmap.js';
-import './service/api/interfaces/beatsaver/resp.js';
-import './service/api/interfaces/beatsaver/user.js';
-import './service/preference.js';
-import './infra/s3/index.js';
-import './service/render/index.js';
-import './service/api/interfaces/beatsaver/ws.js';
-import 'puppeteer-core';
+import { ScreenshotOptions, Viewport, Browser } from 'puppeteer-core';
+import * as ofetch from 'ofetch';
+import { $Fetch, FetchOptions, ResponseType } from 'ofetch';
+
+/**
+ * Extends Puppeteer's ScreenshotOptions to include an optional viewport setting
+ * and a selector for element-specific screenshots.
+ */
+interface RenderOptions$1 extends ScreenshotOptions {
+    /**
+     * Sets the viewport of the page.
+     */
+    viewport?: Viewport;
+    /**
+     * A CSS selector for an element to screenshot. If provided, the output
+     * will be a screenshot of just this element.
+     */
+    selector?: string;
+    /**
+     * The maximum time in milliseconds to wait for the selector to appear.
+     * If the element is not found within this time, an error will be thrown.
+     * Defaults to Puppeteer's default (usually 30000ms).
+     */
+    timeout?: number;
+}
+
+type ExtendFetchOptions<R extends ResponseType = ResponseType, T = any> = {
+    form?: Record<string, any>;
+} & FetchOptions<R, T>;
+declare class Fetch {
+    private options?;
+    private ofetchInstance;
+    constructor(fetchInstance?: $Fetch, options?: FetchOptions);
+    fetch<T, R extends ResponseType>(request: string, options?: ExtendFetchOptions<R, T>): Promise<ofetch.MappedResponseType<R, T>>;
+    get<T = any, R extends ResponseType = 'json'>(request: string, options?: ExtendFetchOptions<R>): Promise<ofetch.MappedResponseType<R, T>>;
+    post<T = any, R extends ResponseType = 'json'>(request: string, options?: ExtendFetchOptions<R>): Promise<ofetch.MappedResponseType<R, T>>;
+    put<T = any, R extends ResponseType = 'json'>(request: string, options?: ExtendFetchOptions<R>): Promise<ofetch.MappedResponseType<R, any>>;
+    patch<T = any, R extends ResponseType = 'json'>(request: string, options?: ExtendFetchOptions<R>): Promise<ofetch.MappedResponseType<R, any>>;
+    delete<T = any, R extends ResponseType = 'json'>(request: string, options?: ExtendFetchOptions<R>): Promise<ofetch.MappedResponseType<R, any>>;
+    head(request: string, options?: FetchOptions): Promise<any>;
+    extend(options: FetchOptions): Fetch;
+    baseUrl(url: string): Fetch;
+}
+
+interface ScoreSaberItem {
+    score: SSScore;
+    leaderboard: LeaderBoard;
+    mapId?: string;
+}
+interface SSScore {
+    id: number;
+    leaderboardPlayerInfo: LeaderboardPlayerInfo;
+    rank: number;
+    baseScore: number;
+    modifiedScore: number;
+    pp: number;
+    weight: number;
+    modifiers: string;
+    multiplier: number;
+    badCuts: number;
+    missedNotes: number;
+    maxCombo: number;
+    fullCombo: boolean;
+    hmd: number;
+    timeSet: string;
+    hasReplay: boolean;
+    deviceHmd: string;
+    deviceControllerLeft: string;
+    deviceControllerRight: string;
+}
+interface LeaderboardPlayerInfo {
+    id: string;
+    name: string;
+    profilePicture: string;
+    country: string;
+    permissions: number;
+    badges?: string;
+    role?: string;
+}
+interface LeaderBoard {
+    id: number;
+    songHash: string;
+    songName: string;
+    songSubName: string;
+    songAuthorName: string;
+    levelAuthorName: string;
+    difficulty: {
+        leaderboardId: number;
+        difficulty: number;
+        gameMode: string;
+        difficultyRaw: string;
+    };
+    maxScore: number;
+    createdDate: string;
+    rankedDate: string;
+    qualifiedDate: string;
+    lovedDate: any;
+    ranked: boolean;
+    qualified: boolean;
+    loved: boolean;
+    maxPP: number;
+    stars: number;
+    plays: number;
+    dailyPlays: number;
+    positiveModifiers: boolean;
+    playerScore: any;
+    coverImage: string;
+    difficulties: any;
+}
+
+interface ScoreSaberUserResponse {
+    playerScores: ScoreSaberItem[];
+    metadata: {
+        total: number;
+        page: number;
+        itemsPerPage: number;
+    };
+}
+
+interface ScoreSaberUser {
+    badges: Badge[];
+    banned: boolean;
+    bio: string;
+    country: string;
+    countryRank: number;
+    firstSeen: string;
+    histories: string;
+    id: string;
+    inactive: boolean;
+    name: string;
+    permissions: number;
+    pp: number;
+    profilePicture: string;
+    rank: number;
+    role: null;
+    scoreStats: ScoreStats;
+    [property: string]: any;
+}
+interface Badge {
+    description?: string;
+    image?: string;
+    [property: string]: any;
+}
+interface ScoreStats {
+    averageRankedAccuracy: number;
+    rankedPlayCount: number;
+    replaysWatched: number;
+    totalPlayCount: number;
+    totalRankedScore: number;
+    totalScore: number;
+    [property: string]: any;
+}
+
+interface Score {
+    accLeft: number;
+    accPP: number;
+    accRight: number;
+    accuracy: number;
+    badCuts: number;
+    baseScore: number;
+    bombCuts: number;
+    bonusPp: number;
+    contextExtensions: null;
+    controller: number;
+    country: null | string;
+    fcAccuracy: number;
+    fcPp: number;
+    fullCombo: boolean;
+    hmd: number;
+    id: number;
+    leaderboard: Leaderboard;
+    leaderboardId: string;
+    maxCombo: number;
+    maxStreak: number | null;
+    metadata: null;
+    missedNotes: number;
+    modifiedScore: number;
+    modifiers: string;
+    myScore: null;
+    offsets: Offsets;
+    passPP: number;
+    pauses: number;
+    platform: string;
+    playCount: number;
+    player: any;
+    playerId: string;
+    pp: number;
+    priority: number;
+    rank: number;
+    rankVoting: null;
+    replay: string;
+    replaysWatched: number;
+    scoreImprovement: ScoreImprovement;
+    techPP: number;
+    timepost: number;
+    timeset: string;
+    validContexts: number;
+    wallsHit: number;
+    weight: number;
+    [property: string]: any;
+}
+interface Leaderboard {
+    difficulty: Difficulty;
+    id: string;
+    song: Song;
+    [property: string]: any;
+}
+interface Difficulty {
+    accRating: number | null;
+    bombs: number;
+    difficultyName: string;
+    duration: number;
+    id: number;
+    maxScore: number;
+    mode: number;
+    modeName: string;
+    modifiersRating: null | ModifiersRating;
+    modifierValues: ModifierValues;
+    njs: number;
+    nominatedTime: number;
+    notes: number;
+    nps: number;
+    passRating: number | null;
+    predictedAcc: number;
+    qualifiedTime: number;
+    rankedTime: number;
+    requirements: number;
+    stars: number | null;
+    status: number;
+    techRating: number | null;
+    type: number;
+    value: number;
+    walls: number;
+    [property: string]: any;
+}
+interface ModifierValues {
+    da: number;
+    fs: number;
+    gn: number;
+    modifierId: number;
+    na: number;
+    nb: number;
+    nf: number;
+    no: number;
+    op: number;
+    pm: number;
+    sa: number;
+    sc: number;
+    sf: number;
+    ss: number;
+    [property: string]: any;
+}
+interface ModifiersRating {
+    fsAccRating: number;
+    fsPassRating: number;
+    fsPredictedAcc: number;
+    fsStars: number;
+    fsTechRating: number;
+    id: number;
+    sfAccRating: number;
+    sfPassRating: number;
+    sfPredictedAcc: number;
+    sfStars: number;
+    sfTechRating: number;
+    ssAccRating: number;
+    ssPassRating: number;
+    ssPredictedAcc: number;
+    ssStars: number;
+    ssTechRating: number;
+    [property: string]: any;
+}
+interface Song {
+    author: string;
+    bpm: number;
+    collaboratorIds: null;
+    coverImage: string;
+    duration: number;
+    fullCoverImage: string;
+    hash: string;
+    id: string;
+    mapper: string;
+    mapperId: number;
+    name: string;
+    subName: string;
+    [property: string]: any;
+}
+interface Offsets {
+    frames: number;
+    heights: number;
+    id: number;
+    notes: number;
+    pauses: number;
+    walls: number;
+    [property: string]: any;
+}
+interface ScoreImprovement {
+    accLeft: number;
+    accRight: number;
+    accuracy: number;
+    averageRankedAccuracy: number;
+    badCuts: number;
+    bombCuts: number;
+    bonusPp: number;
+    id: number;
+    missedNotes: number;
+    pauses: number;
+    pp: number;
+    rank: number;
+    score: number;
+    timeset: string;
+    totalPp: number;
+    totalRank: number;
+    wallsHit: number;
+    [property: string]: any;
+}
+
+interface BeatLeaderPlayerScoreRequest {
+    diff: string;
+    mode: string;
+    hash: string;
+    playerID: string;
+    leaderboardContext: string;
+}
+interface Metadata$1 {
+    itemsPerPage: number;
+    page: number;
+    total: number;
+    [property: string]: any;
+}
+interface BeadLeaderScoresResponse {
+    data: Score[];
+    metadata: Metadata$1;
+    [property: string]: any;
+}
+
+interface BeatLeaderUser {
+    accPp: number;
+    avatar: string;
+    badges: BLBadge[];
+    banDescription: null;
+    banned: boolean;
+    bot: boolean;
+    changes: BLChange[];
+    clanOrder: string;
+    clans: BLClan[];
+    contextExtensions: null;
+    country: string;
+    countryRank: number;
+    eventsParticipating: null;
+    externalProfileUrl: string;
+    history: null;
+    id: string;
+    inactive: boolean;
+    lastWeekCountryRank: number;
+    lastWeekPp: number;
+    lastWeekRank: number;
+    mapperId: number;
+    name: string;
+    passPp: number;
+    patreonFeatures: null;
+    pinnedScores: null;
+    platform: string;
+    pp: number;
+    profileSettings: BLProfileSettings;
+    rank: number;
+    role: string;
+    scoreStats: BLScoreStats;
+    socials: BLSocial[];
+    techPp: number;
+    topHMD: number;
+    sspPlays: number;
+    ssPlays: number;
+    spPlays: number;
+    sPlays: number;
+    aPlays: number;
+    [property: string]: any;
+}
+interface BLBadge {
+    description: string;
+    hidden: boolean;
+    id: number;
+    image: string;
+    link: string;
+    timeset: number;
+    [property: string]: any;
+}
+interface BLChange {
+    changer: null | string;
+    id: number;
+    newCountry: null | string;
+    newName: null | string;
+    oldCountry: string;
+    oldName: null | string;
+    playerId: string;
+    timestamp: number;
+    [property: string]: any;
+}
+interface BLClan {
+    color: string;
+    id: number;
+    name: null;
+    tag: string;
+    [property: string]: any;
+}
+interface BLProfileSettings {
+    bio: null;
+    effectName: string;
+    hue: number;
+    id: number;
+    leftSaberColor: string;
+    message: null;
+    profileAppearance: string;
+    profileCover: string;
+    rightSaberColor: string;
+    saturation: number;
+    showAllRatings: boolean;
+    showBots: boolean;
+    starredFriends: string;
+    [property: string]: any;
+}
+interface BLScoreStats {
+    anonimusReplayWatched: number;
+    aPlays: number;
+    authorizedReplayWatched: number;
+    averageAccuracy: number;
+    averageLeftTiming: number;
+    averageRank: number;
+    averageRankedAccuracy: number;
+    averageRankedRank: number;
+    averageRightTiming: number;
+    averageUnrankedAccuracy: number;
+    averageUnrankedRank: number;
+    averageWeightedRankedAccuracy: number;
+    averageWeightedRankedRank: number;
+    countryTopPercentile: number;
+    dailyImprovements: number;
+    id: number;
+    lastRankedScoreTime: number;
+    lastScoreTime: number;
+    lastUnrankedScoreTime: number;
+    maxStreak: number;
+    medianAccuracy: number;
+    medianRankedAccuracy: number;
+    peakRank: number;
+    rankedImprovementsCount: number;
+    rankedMaxStreak: number;
+    rankedPlayCount: number;
+    rankedTop1Count: number;
+    rankedTop1Score: number;
+    sPlays: number;
+    spPlays: number;
+    ssPlays: number;
+    sspPlays: number;
+    top1Count: number;
+    top1Score: number;
+    topAccPP: number;
+    topAccuracy: number;
+    topBonusPP: number;
+    topHMD: number;
+    topPassPP: number;
+    topPercentile: number;
+    topPlatform: string;
+    topPp: number;
+    topRankedAccuracy: number;
+    topTechPP: number;
+    topUnrankedAccuracy: number;
+    totalImprovementsCount: number;
+    totalPlayCount: number;
+    totalRankedScore: number;
+    totalScore: number;
+    totalUnrankedScore: number;
+    unrankedImprovementsCount: number;
+    unrankedMaxStreak: number;
+    unrankedPlayCount: number;
+    unrankedTop1Count: number;
+    unrankedTop1Score: number;
+    watchedReplays: number;
+    [property: string]: any;
+}
+interface BLSocial {
+    id: number;
+    link: string;
+    playerId: string;
+    service: string;
+    user: string;
+    userId: string;
+    [property: string]: any;
+}
+
+interface ScoresaberLeaderboardResp {
+    scores: SSScore[];
+    metadata: Metadata;
+}
+interface Metadata {
+    total: number;
+    page: number;
+    itemsPerPage: number;
+}
+
+declare class ScoreSaberClient {
+    f: Fetch;
+    constructor(logger: Logger);
+    getScoreUserById(userId: string): Promise<ScoreSaberUser>;
+    getScoreItemsById(userId: string, page: number, pageSize?: number): Promise<ScoreSaberUserResponse>;
+    getScoreItemsByMapId(mapId: string, diff: string, mode: string, page: number, pageSize?: number): Promise<ScoresaberLeaderboardResp>;
+}
+
+interface OAuthTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    scope?: string;
+}
+interface OAuthTokenInfoResponse {
+    scope?: string[];
+    id: string;
+    name: string;
+}
+
+type ClientOptions$1 = {
+    client_id?: string;
+    client_secret?: string;
+    logger?: Logger;
+};
+declare class BeatLeaderClient {
+    f: Fetch;
+    opt?: ClientOptions$1;
+    constructor(opt?: ClientOptions$1);
+    getPlayerScore(req: BeatLeaderPlayerScoreRequest): Promise<Leaderboard>;
+    getTokenInfo(accessToken: string): Promise<OAuthTokenInfoResponse>;
+    refreshOAuthToken(refreshToken: string): Promise<OAuthTokenResponse>;
+    getPlayerInfo(accountId: string): Promise<BeatLeaderUser>;
+    getPlayerScores(accountId: string): Promise<BeadLeaderScoresResponse>;
+    getPlayerPinnedScores(accountId: string): Promise<Score[]>;
+    getBeatScore(scoreId: string): Promise<Score>;
+    getLeaderboard(leaderboardId: string, params?: Record<string, any>): Promise<any>;
+}
+
+interface AioOauthTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    scope?: string;
+}
+
+declare class AIOSaberClient {
+    f: Fetch;
+    constructor(logger: Logger);
+    getBSOAuthToken(key: string): Promise<AioOauthTokenResponse>;
+    getBLOAuthToken(key: string): Promise<AioOauthTokenResponse>;
+}
+
+interface BSMap {
+    id: string;
+    name: string;
+    description: string;
+    declaredAi: string;
+    uploader: {
+        id: number;
+        name: string;
+        avatar: string;
+        type: string;
+        [key: string]: any;
+    };
+    metadata: {
+        bpm: number;
+        duration: number;
+        songName: string;
+        songSubName: string;
+        songAuthorName: string;
+        levelAuthorName: string;
+    };
+    stats: {
+        plays: number;
+        downloads: number;
+        upvotes: number;
+        downvotes: number;
+        score: number;
+        reviews?: number;
+        [key: string]: any;
+    };
+    automapper: boolean;
+    versions: {
+        hash: string;
+        state: string;
+        createdAt: string;
+        downloadURL: string;
+        coverURL: string;
+        previewURL: string;
+        sageScore?: number;
+        diffs: {
+            notes: number;
+            bombs: number;
+            offset: number;
+            obstacles: number;
+            nps: number;
+            length: number;
+            characteristic: string;
+            difficulty: string;
+            events: number;
+            chroma: boolean;
+            me: boolean;
+            ne: boolean;
+            cinema: boolean;
+            seconds: number;
+            maxScore: number;
+            paritySummary: any;
+            star?: number;
+            blStar?: number;
+            [key: string]: any;
+        }[];
+    }[];
+    lastPublishedAt: string;
+    updatedAt: string;
+    createdAt: string;
+    tags: string[];
+    ranked?: boolean;
+    blRanked?: boolean;
+    [key: string]: any;
+}
+
+interface DeleteEvent {
+    type: 'MAP_DELETE';
+    msg: string;
+}
+interface UpdateEvent {
+    type: 'MAP_UPDATE';
+    msg: BSMap;
+}
+type BeatSaverWSEvent = DeleteEvent | UpdateEvent;
+
+interface HashResponse {
+    [hash: string]: BSMap;
+}
+type HashReqResponse = BSMap | HashResponse;
+
+interface BSUserResponse {
+    id: number;
+    name: string;
+    admin: boolean;
+    avatar: boolean;
+    curator: boolean;
+    description: string;
+}
+
+type ClientOptions = {
+    logger?: Logger;
+    host?: string;
+    client_id?: string;
+    client_secret?: string;
+    f?: Fetch;
+};
+declare class BeatSaverClient {
+    f: Fetch;
+    opt?: ClientOptions;
+    constructor(opt?: ClientOptions);
+    getBSMapperById(userId: string): Promise<BSUserResponse>;
+    getLatestMaps(pageSize?: number): Promise<BSMap[]>;
+    searchMapByKeyword(key: string, params?: Record<string, boolean | number | string>): Promise<BSMap[]>;
+    searchMapById(id: string): Promise<BSMap>;
+    getTokenInfo(ak: string): Promise<OAuthTokenInfoResponse>;
+    getMapsByHashes(hashes: string[]): Promise<HashReqResponse>;
+    refreshOAuthToken(rk: string): Promise<OAuthTokenResponse>;
+}
+
+type MapDiffOption = {
+    difficulty?: string;
+    mode?: string;
+};
+declare class APIService {
+    BeatLeader: BeatLeaderClient;
+    ScoreSaber: ScoreSaberClient;
+    BeatSaver: BeatSaverClient;
+    AIOSaber: AIOSaberClient;
+    constructor(cfg: Config, logger: Logger);
+    getBLPlayerScoresWithUserInfo(accountId: string): Promise<{
+        scores: Score[];
+        userInfo: BeatLeaderUser;
+    }>;
+    getSSPlayerScoresWithUserInfo(accountId: string): Promise<void>;
+    getScoreByPlayerIdAndMapId(playerId: string, mapId: string, option?: MapDiffOption): Promise<Leaderboard>;
+    getAroundScoreAndRegionScoreByRankAndPage(leaderboardId: string, rank: number, regionCode: string): Promise<{
+        difficulties: any;
+        aroundScores: any;
+        regionTopScores: any;
+    }>;
+    getScoreAndBSMapByScoreId(scoreId: string): Promise<{
+        score: Score;
+        bsMap: BSMap;
+        statistic: any;
+        bsor: unknown;
+    }>;
+    getSSPlayerRecentScoreWithUserInfo(uid: string): Promise<{
+        scores: ScoreSaberItem[];
+        userInfo: ScoreSaberUser;
+    }>;
+}
+
+declare class UserPreferenceStore {
+    private db;
+    private uid;
+    v: any;
+    constructor(db: DB<any>, uid: number);
+    getUserPreference(uid: number): Promise<UserPreferenceStore>;
+    set<T extends string | number | boolean>(key: string, value: T): Promise<boolean>;
+    get<T extends string | number | boolean>(key: string): Promise<T | undefined>;
+    configEntries(): Promise<Record<string, any>>;
+}
+
+type RenderOption = RenderOptions & RenderOptions$1;
+type RenderOptions = {
+    userPreference?: UserPreferenceStore;
+    onRenderStart?: () => void;
+    onRenderError?: (e: any) => void;
+};
+interface IRenderService {
+    renderRank(accountId: string, platform: Platform, renderOpts?: RenderOption): Promise<Buffer>;
+    renderScore(scoreId: string, renderOpts?: RenderOption): Promise<Buffer>;
+    renderMapById(mapId: string, renderOpts?: RenderOption): Promise<Buffer>;
+    renderMap(bsMap: BSMap, renderOpts?: RenderOption): Promise<Buffer>;
+    renderUrl(url: string, renderOpts?: RenderOption): Promise<Buffer>;
+}
+
+declare class RenderService implements IRenderService {
+    private api;
+    private imageRender;
+    constructor(api: APIService, imageRender: ImageRender);
+    static create(imgRenderConfig: CreateImageRenderOption, api: APIService): RenderService;
+    renderRank(accountId: string, platform: Platform, renderOpts?: RenderOption): Promise<Buffer>;
+    renderScore(scoreId: string, renderOpts?: RenderOption): Promise<Buffer>;
+    renderMapById(mapId: string, renderOption: RenderOption): Promise<Buffer>;
+    renderMap(bsMap: BSMap, renderOption?: RenderOption): Promise<Buffer>;
+    renderUrl(url: string, renderOption?: RenderOption): Promise<Buffer>;
+}
+
+interface RelateAccount {
+    id: number;
+    uid: number;
+    type: string;
+    platform: string;
+    platformUname: string;
+    platformUid: string;
+    platformScope: string;
+    accessToken: string;
+    refreshToken: string;
+    otherPlatformInfo: any;
+    lastModifiedAt: Date;
+    lastRefreshAt: Date;
+    status: string;
+}
+interface SubscribeMember {
+    subscribeId: number;
+    memberUid: number;
+    subscribeData: any;
+    joinedAt: Date;
+}
+interface Subscribe {
+    id: number;
+    gid: number;
+    type: string;
+    time: Date;
+    enable: boolean;
+    data: any;
+}
+type RelateChannelInfo<CHANNEL> = {
+    id: number;
+    name: string;
+    type: 'user' | 'group' | string;
+} & CHANNEL;
+type UserPreference<T = any> = {
+    uid: number;
+    gid: number;
+    data: T;
+};
+
+interface SubInfoRes {
+    subscribe: Subscribe;
+    memberCount: number;
+    me: any;
+}
+interface SubInfoRes {
+    subscribe: Subscribe;
+    memberCount: number;
+    me: any;
+}
+interface SubDetailWithGroupRes<T> {
+    account: RelateAccount;
+    accountChannel: RelateChannelInfo<T>;
+    subscribeMember: SubscribeMember;
+    subscribe: Subscribe;
+    groupChannel: RelateChannelInfo<T>;
+}
+interface SubWithGroupRes<T> {
+    subscribe: Subscribe;
+    groupChannel: RelateChannelInfo<T>;
+}
+interface DB<T> {
+    storeUserPreference<V = any>(uid: number, value: V): Promise<boolean>;
+    getUserPreference<V = any>(uid: number): Promise<V>;
+    getUserAccountsByUid(id: number): Promise<Record<string, RelateAccount>>;
+    batchGetOrCreateUBySessionInfo(s: T[]): Promise<RelateChannelInfo<T>[]>;
+    getUAndGBySessionInfo(s: T): Promise<[RelateChannelInfo<T>, RelateChannelInfo<T>]>;
+    addUserBindingInfo(account: Partial<RelateAccount>): Promise<void>;
+    upsertSubscription(data: Partial<Subscribe>): Promise<void>;
+    getSubscriptionInfoByUGID(gid: number, uid: number): Promise<SubInfoRes[]>;
+    getSubscriptionsByGID(gid: number): Promise<Record<string, Subscribe>>;
+    getIDSubscriptionByGID(gid: number): Promise<Subscribe[]>;
+    getIDSubscriptionByType(type: string): Promise<SubWithGroupRes<T>[]>;
+    removeIDSubscriptionByID(id: number): Promise<void>;
+    getIDSubscriptionByGIDAndType(gid: number, type: string): Promise<Subscribe[]>;
+    getAllSubscriptionByUIDAndPlatform(id: string | number, type: string): Promise<SubDetailWithGroupRes<T>[]>;
+    getSubscriptionsByType(type: string): Promise<SubDetailWithGroupRes<T>[]>;
+    addSubscribeMember(data: Partial<SubscribeMember>): Promise<void>;
+    removeFromSubGroupBySubAndUid(subId: number, id: number): Promise<void>;
+}
+
+interface Logger {
+    info(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    error(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+}
+
+type ChannelInfo = any;
+interface BotService<T extends ChannelInfo, S extends Session<T>> {
+    getSessionByChannelInfo(channelInfo: T): S;
+}
+interface Session<T extends any = any> {
+    u: RelateChannelInfo<T>;
+    g: RelateChannelInfo<T>;
+    mentions: (RelateChannelInfo<T> | undefined)[];
+    getSessionInfo(): T;
+    sendImgBuffer(content: any, mimeType?: string): Promise<void>;
+    sendImgByUrl(url: string): Promise<void>;
+    sendAudioByUrl(url: string): Promise<void>;
+    send(msg: string): Promise<void>;
+    sendQueued(msg: string): Promise<void>;
+    sendQuote(msg: string): Promise<void>;
+    text(path: string, args?: any): string;
+    prompt(timeout?: number): Promise<string | undefined>;
+}
+
+interface CmdContext<CHANNEL, OPT> {
+    logger: Logger;
+    config: Config;
+    session: Session;
+    options: OPT;
+    services: Services<CHANNEL>;
+    input: string;
+}
+type CmdExecutor<CHANNEL, OPT extends object = object> = (c: CmdContext<CHANNEL, OPT>) => Promise<void>;
+interface CmdOption {
+    type: 'boolean' | 'number' | 'string';
+    name: string;
+    short?: string;
+    description?: string;
+    required?: boolean;
+}
+type CmdAlias = {
+    alias: string;
+    option?: object;
+};
+interface Command<CHANNEL> {
+    name: string;
+    description: string;
+    aliases: CmdAlias[];
+    options: CmdOption[];
+    callback: CmdExecutor<CHANNEL>;
+    children: Command<CHANNEL>[];
+}
+type Extend<BASE extends {}, N extends string, D> = {
+    [P in N | keyof BASE]?: (P extends keyof BASE ? BASE[P] : unknown) & (P extends N ? D : unknown);
+};
+type ExtractType<T extends string> = T extends 'string' ? string : T extends 'boolean' ? boolean : T extends 'number' ? number : any;
+type Nullable<T> = T | null;
+type ExtractNullSafeType<T extends string> = T extends `${infer Type}?` ? Nullable<ExtractType<Type>> : ExtractType<T>;
+type OptionType<T extends string> = T extends `${infer L}:${infer R}` ? ExtractNullSafeType<R> : unknown;
+
+declare enum Platform {
+    SS = "scoresaber",
+    BS = "beatsaver",
+    BL = "beatleader"
+}
+declare const parsePlatform: (p: string) => Platform.SS | Platform.BL;
+type Services<T> = {
+    render: RenderService;
+    api: APIService;
+    db: DB<T>;
+};
+
+interface ImageRender {
+    html2img: (html: string, opt: RenderOptions$1) => Promise<Buffer>;
+    url2img: (url: string, opt: RenderOptions$1) => Promise<Buffer>;
+}
+type RenderConfig = {
+    mode: 'cf' | 'puppeteer' | 'custom';
+    puppeteerURL?: string;
+    defaultWaitTimeout?: number;
+    waitTimeout?: number;
+    cfAccountId?: string;
+    cfAPIKey?: string;
+};
+declare class CFBrowserRendering implements ImageRender {
+    f: Fetch;
+    constructor(accountId: string, cfAPIKey: string);
+    private post;
+    html2img(html: string, opt: RenderOptions$1): Promise<Buffer>;
+    url2img(url: string, opt: RenderOptions$1): Promise<Buffer>;
+}
+declare class PuppeteerRendering implements ImageRender {
+    private browserGetter;
+    constructor(browserGetter: () => Promise<Browser>);
+    html2img(html: string, opt: RenderOptions$1): Promise<Buffer>;
+    url2img(html: string, opt: RenderOptions$1): Promise<Buffer>;
+}
+declare const RemoteBrowserGetter: (addr: string) => () => Promise<Browser>;
+declare const getImageRender: (cfg: RenderConfig & {
+    render?: ImageRender;
+    browserGetter?: () => Promise<Browser>;
+}) => ImageRender;
+type CreateImageRenderOption = Parameters<typeof getImageRender>[0];
+
+declare class I18nService {
+    obj: any;
+    constructor(config?: any);
+    mergeConfig(lang: string, obj: any): void;
+    loadLang(lang: string): void;
+    tran(path: string, params?: {}, lang?: string): string;
+}
+
+interface S3Config {
+    s3AccessKey: string;
+    s3SecretKey: string;
+    endpoint: string;
+    region: string | undefined;
+    bucketName: string;
+    keyPrefix: string;
+    baseURL: string;
+}
+declare class S3Service {
+    private s3Client;
+    private readonly bucket;
+    private readonly keyPrefix;
+    private readonly baseURL;
+    constructor(config: S3Config);
+    uploadImgWithUrl(url: string, mimeType?: string): Promise<string>;
+    uploadImg(buffer: Buffer, mimeType?: string): Promise<string>;
+}
+
+interface Config {
+    s3: {
+        enabled: boolean;
+    } & S3Config;
+    render: RenderConfig;
+    minRawMatchMapIdLength: number;
+    beatSaverHost: string;
+    beatSaverWSURL: string;
+    bsOauthClientId: string;
+    bsOauthClientSecret: string;
+    blOauthClientId: string;
+    blOauthClientSecret: string;
+    bsNotifyMonitorCron: ScheduleTaskConfig;
+    tokenRefreshCron: ScheduleTaskConfig;
+    tempCron: ScheduleTaskConfig;
+}
+interface ScheduleTaskConfig {
+    cron: string;
+    enabled: boolean;
+}
+
+type ScheduleTaskCtx<T> = {
+    config: Config;
+    logger: Logger;
+    services: Services<T>;
+    botService: BotService<T, Session<T>>;
+};
+
+declare const getScheduleTasks: (config: Config) => {
+    name: string;
+    handler: <T>(c: ScheduleTaskCtx<T>) => Promise<void>;
+    cron: string;
+    enabled: boolean;
+}[];
+
+declare const botCommands: <CHANNEL>() => Command<CHANNEL>[];
+
+interface WSHandler {
+    wsUrl: string;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onEvent?: (event: any) => void;
+}
+
+declare class BeatleaderWSHandler<T> implements WSHandler {
+    private readonly logger;
+    private render;
+    private botService;
+    wsUrl: string;
+    private db;
+    config: Config;
+    constructor(db: DB<T>, render: RenderService, logger: Logger, config: Config, botService: BotService<T, Session<T>>);
+    onOpen(): void;
+    onClose(): void;
+    onEvent(event: any): Promise<void>;
+}
+
+declare class BeatSaverWSHandler<T> implements WSHandler {
+    private readonly logger;
+    private render;
+    private botService;
+    wsUrl: string;
+    private db;
+    config: Config;
+    constructor(db: DB<T>, render: RenderService, logger: Logger, config: Config, botService: BotService<T, Session<T>>);
+    onOpen(): void;
+    onClose(): void;
+    eventParser(event: any): BeatSaverWSEvent;
+    eventFilter: (data: BeatSaverWSEvent) => boolean;
+    eventIdSelector: (data: BeatSaverWSEvent) => string;
+    BSWSHandler(data: BeatSaverWSEvent): Promise<void>;
+    onEvent: (event: any) => Promise<void>;
+}
+
+declare const handleWSEventWithCache: (fnThat: any, fn: any, ttl: any, eventParser: any, eventFilter: any, eventIdSelector: any) => (event: any) => Promise<void>;
+declare const sleep: (millsec?: number) => Promise<void>;
+declare const convertDiff: (diff: string | null) => any;
 
 declare const getBot: <T>(config: Config) => {
     commands: Command<T>[];
@@ -47,8 +1033,8 @@ declare const getBot: <T>(config: Config) => {
         name: string;
         handler: <T_1>(c: ScheduleTaskCtx<T_1>) => Promise<void>;
         cron: string;
-        enable: boolean;
+        enabled: boolean;
     }[];
 };
 
-export { Command, Config, getBot };
+export { APIService, BeatSaverWSHandler, BeatleaderWSHandler, type BotService, CFBrowserRendering, type CmdAlias, type CmdContext, type CmdExecutor, type CmdOption, type Command, type Config, type CreateImageRenderOption, type DB, type Extend, I18nService, type ImageRender, type Logger, type OptionType, Platform, type RenderOptions$1 as PuppeteerOptions, PuppeteerRendering, type RelateAccount, type RelateChannelInfo, RemoteBrowserGetter, type RenderConfig, RenderService, type S3Config, S3Service, type Services, type Session, type SubDetailWithGroupRes, type SubInfoRes, type SubWithGroupRes, type Subscribe, type SubscribeMember, type UserPreference, type WSHandler, botCommands, convertDiff, getBot, getImageRender, getScheduleTasks, handleWSEventWithCache, parsePlatform, sleep };