beatsaber-bot-core 0.2.0-rc.8 → 0.3.0-rc.1

package/dist/types/index.d.ts

@@ -1,54 +1,1382 @@
-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';
-
-declare const getBot: <T>(config: Config) => {
-    commands: Command<T>[];
+import * as ofetch from 'ofetch';
+import { $Fetch, FetchOptions, ResponseType } from 'ofetch';
+import { z } from 'zod/v4';
+import { ScreenshotOptions, Viewport, Browser } from 'puppeteer-core';
+
+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 User$1 = {
+    id: string;
+    name: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+};
+type Channel$1 = {
+    id: string;
+    channelId: string;
+    providerId: string;
+};
+type SessionAgent = {
+    id: string;
+    providerId: string;
+    accountId: string;
+    status: string;
+    enabled: boolean;
+};
+
+type Message = string;
+interface ISession {
+    sendImgBuffer(content: any, mimeType?: string): Promise<void>;
+    sendImgByUrl(url: string): Promise<void>;
+    sendAudioByUrl(url: string): Promise<void>;
+    send(msg: Message): Promise<void>;
+    sendQueued(msg: Message): Promise<void>;
+    sendQuote(msg: Message): Promise<void>;
+    text(path: string, args?: any): Message;
+    prompt(timeout?: number): Promise<Message | undefined>;
+}
+interface PassiveSession extends ISession {
+    user: User$1;
+    channel: Channel$1;
+    mentions: User$1[];
+    agent: SessionAgent;
+}
+interface AgentService {
+    getAgentSessionByChannelInfo(channel: Channel$1): PositiveSession;
+}
+interface PositiveSession extends ISession {
+    channel: Channel$1;
+    agent: SessionAgent;
+}
+
+interface CmdContext$1<Service, Cfg, OPT> {
+    logger: Logger;
+    session: PassiveSession;
+    config: Cfg;
+    services: Service;
+    options: OPT;
+    input?: string;
+}
+type CmdExecutor<Service, Cfg, OPT> = (c: CmdContext$1<Service, Cfg, OPT>) => Promise<void>;
+interface CmdOption {
+    type: 'boolean' | 'number' | 'string';
+    name: string;
+    short?: string;
+    description?: string;
+    required?: boolean;
+}
+type CmdAlias = {
+    alias: string;
+    option?: {};
+};
+interface Command$1<Service, Cfg, OPT> {
+    name: string;
+    description: string;
+    aliases: CmdAlias[];
+    options: CmdOption[];
+    callback: CmdExecutor<Service, Cfg, OPT>;
+}
+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 class CommandBuilder$1<Service, Config, OPT extends {} = {}> {
+    private name;
+    private description;
+    private options;
+    private aliases;
+    constructor();
+    addOption<N extends string, D extends string>(name: N, description: D): CommandBuilder$1<Service, Config, Extend<OPT, N, OptionType<D>>>;
+    addAlias(alias: string, option?: object): this;
+    setName<T extends string>(name: T): this;
+    setDescription(description: string): this;
+    setExecutor(executor: CmdExecutor<Service, Config, OPT>): {
+        name: string;
+        description: string;
+        aliases: CmdAlias[];
+        options: CmdOption[];
+        callback: (c: CmdContext$1<Service, Config, OPT>) => Promise<void>;
+        children: any[];
+    };
+}
+
+type EventHandlerCtx<Service, Config> = {
+    config: Config;
+    logger: Logger;
+    services: Service;
+    agentService: AgentService;
+};
+
+interface User {
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface Channel {
+    id: string;
+    channelId: string;
+    providerId: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+interface Account<T = any> {
+    id: string;
+    userId: string;
+    providerId: string;
+    accountId: string;
+    type: string;
+    providerUsername?: string;
+    scope?: string;
+    accessToken?: string;
+    accessTokenExpiresAt?: Date;
+    refreshToken?: string;
+    refreshTokenExpiresAt?: Date;
+    idToken?: string;
+    metadata?: T;
+    lastModifiedAt: Date;
+    lastRefreshAt: Date;
+    createdAt: Date;
+}
+interface Subscription {
+    id: string;
+    channelId: string;
+    type: string;
+    enabled: boolean;
+    data: any;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface SubscriptionMember {
+    subscribeId: string;
+    memberId: string;
+    subscribeData: any;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type Preference<T = any> = {
+    userId: string;
+    channelId: string;
+    data: T;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+interface SubInfoRes {
+    subscription: Subscription;
+    memberCount: number;
+    me: any;
+}
+interface SubInfoRes {
+    subscription: Subscription;
+    memberCount: number;
+    me: any;
+}
+interface SubDetailWithGroupRes {
+    account: Account;
+    user: User$1;
+    channel: Channel$1;
+    subscriptionMember: SubscriptionMember;
+    subscription: Subscription;
+}
+interface SubWithGroupRes {
+    subscription: Subscription;
+    channel: Channel$1;
+}
+interface DB {
+    storeUserPreference<V = any>(uid: string, value: V): Promise<boolean>;
+    getUserPreference<V = any>(uid: string): Promise<V>;
+    getUserAccountsByUid(id: string): Promise<Record<string, Account>>;
+    addUserBindingInfo(account: Partial<Account>): Promise<void>;
+    upsertSubscription(data: Partial<Subscription>): Promise<void>;
+    getSubscriptionInfoByUGID(gid: string, uid: string): Promise<SubInfoRes[]>;
+    getSubscriptionsByGID(gid: string): Promise<Record<string, Subscription>>;
+    getIDSubscriptionByGID(gid: string): Promise<Subscription[]>;
+    getIDSubscriptionByType(type: string): Promise<SubWithGroupRes[]>;
+    removeIDSubscriptionByID(id: string): Promise<void>;
+    getIDSubscriptionByChannelIDAndType(gid: string, type: string): Promise<Subscription[]>;
+    getAllSubscriptionByUIDAndPlatform(id: string, type: string): Promise<SubDetailWithGroupRes[]>;
+    getSubscriptionsByType(type: string): Promise<SubWithGroupRes[]>;
+    addSubscribeMember(data: Partial<SubscriptionMember>): Promise<void>;
+    removeFromSubGroupBySubAndUid(subId: string, id: string): Promise<void>;
+}
+
+declare class I18nService {
+    translator: (path: string, params: any, lang: string) => string;
+    constructor(config?: any);
+    mergeConfig(lang: string, obj: any): void;
+    loadLang(lang: string): void;
+    tran(path: string, params?: {}, lang?: string): string;
+}
+
+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;
+}
+
+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;
+}
+
+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>;
+}
+
+declare const configSchema: z.ZodObject<{
+    s3: z.ZodOptional<z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        s3AccessKey: z.ZodString;
+        s3SecretKey: z.ZodString;
+        endpoint: z.ZodString;
+        baseURL: z.ZodString;
+        bucketName: z.ZodString;
+        region: z.ZodOptional<z.ZodString>;
+        keyPrefix: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, z.core.$strip>]>>>;
+    render: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+        waitTimeout: z.ZodOptional<z.ZodNumber>;
+        cfAccountId: z.ZodString;
+        cfAPIKey: z.ZodString;
+        mode: z.ZodLiteral<"cf">;
+    }, z.core.$strip>, z.ZodObject<{
+        defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+        waitTimeout: z.ZodOptional<z.ZodNumber>;
+        puppeteerURL: z.ZodOptional<z.ZodString>;
+        mode: z.ZodLiteral<"puppeteer">;
+    }, z.core.$strip>, z.ZodObject<{
+        defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+        waitTimeout: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>]>, z.ZodObject<{
+        defaultWaitTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        waitTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        puppeteerURL: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        cfAccountId: z.ZodOptional<z.ZodString>;
+        cfAPIKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    beatsaver: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        host: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        wsURL: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        oauthClientId: z.ZodOptional<z.ZodString>;
+        oauthClientSecret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    beatleader: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        oauthClientId: z.ZodOptional<z.ZodString>;
+        oauthClientSecret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    cron: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        temp: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            cron: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Config = z.infer<typeof configSchema>;
+
+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 | null>;
+    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 enum Platform {
+    SS = "scoresaber",
+    BS = "beatsaver",
+    BL = "beatleader"
+}
+declare const parsePlatform: (p: string) => Platform.SS | Platform.BL;
+
+declare function checkBSORFile(file: any, completion: any): void;
+declare function decode(arrayBuffer: any, completion: any): void;
+declare function decodeAsync(arrayBuffer: any): Promise<{
+    info: {
+        version: string;
+        gameVersion: string;
+        timestamp: string;
+        playerID: string;
+        playerName: string;
+        platform: string;
+        trackingSystem: string;
+        hmd: string;
+        controller: string;
+        hash: string;
+        songName: string;
+        mapper: string;
+        difficulty: string;
+        score: any;
+        mode: string;
+        environment: string;
+        modifiers: string;
+        jumpDistance: any;
+        leftHanded: boolean;
+        height: any;
+        startTime: any;
+        failTime: any;
+        speed: any;
+    };
+    frames: {
+        time: any;
+        fps: any;
+        head: {
+            position: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            rotation: {
+                x: any;
+                y: any;
+                z: any;
+                w: any;
+            };
+        };
+        left: {
+            position: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            rotation: {
+                x: any;
+                y: any;
+                z: any;
+                w: any;
+            };
+        };
+        right: {
+            position: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            rotation: {
+                x: any;
+                y: any;
+                z: any;
+                w: any;
+            };
+        };
+    }[];
+    notes: {
+        noteID: any;
+        eventTime: any;
+        spawnTime: any;
+        eventType: any;
+        noteCutInfo: {
+            speedOK: boolean;
+            directionOK: boolean;
+            saberTypeOK: boolean;
+            wasCutTooSoon: boolean;
+            saberSpeed: any;
+            saberDir: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            saberType: any;
+            timeDeviation: any;
+            cutDirDeviation: any;
+            cutPoint: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            cutNormal: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            cutDistanceToCenter: any;
+            cutAngle: any;
+            beforeCutRating: any;
+            afterCutRating: any;
+        };
+    }[];
+    walls: {
+        wallID: any;
+        energy: any;
+        time: any;
+        spawnTime: any;
+    }[];
+    heights: {
+        height: any;
+        time: any;
+    }[];
+    pauses: {
+        duration: any;
+        time: any;
+    }[];
+}>;
+declare function DecodeInfo(dataView: any): {
+    version: string;
+    gameVersion: string;
+    timestamp: string;
+    playerID: string;
+    playerName: string;
+    platform: string;
+    trackingSystem: string;
+    hmd: string;
+    controller: string;
+    hash: string;
+    songName: string;
+    mapper: string;
+    difficulty: string;
+    score: any;
+    mode: string;
+    environment: string;
+    modifiers: string;
+    jumpDistance: any;
+    leftHanded: boolean;
+    height: any;
+    startTime: any;
+    failTime: any;
+    speed: any;
+};
+declare function DecodeNotes(dataView: any): {
+    noteID: any;
+    eventTime: any;
+    spawnTime: any;
+    eventType: any;
+    noteCutInfo: {
+        speedOK: boolean;
+        directionOK: boolean;
+        saberTypeOK: boolean;
+        wasCutTooSoon: boolean;
+        saberSpeed: any;
+        saberDir: {
+            x: any;
+            y: any;
+            z: any;
+        };
+        saberType: any;
+        timeDeviation: any;
+        cutDirDeviation: any;
+        cutPoint: {
+            x: any;
+            y: any;
+            z: any;
+        };
+        cutNormal: {
+            x: any;
+            y: any;
+            z: any;
+        };
+        cutDistanceToCenter: any;
+        cutAngle: any;
+        beforeCutRating: any;
+        afterCutRating: any;
+    };
+}[];
+declare namespace NoteEventType {
+    let good: number;
+    let bad: number;
+    let miss: number;
+    let bomb: number;
+}
+
+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;
+
+/**
+ * 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;
+}
+
+interface ImageRender {
+    html2img: (html: string, opt: RenderOptions$1) => Promise<Buffer>;
+    url2img: (url: string, opt: RenderOptions$1) => Promise<Buffer>;
+}
+declare const strictRenderConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    cfAccountId: z.ZodString;
+    cfAPIKey: z.ZodString;
+    mode: z.ZodLiteral<"cf">;
+}, z.core.$strip>, z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    puppeteerURL: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"puppeteer">;
+}, z.core.$strip>, z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"custom">;
+}, z.core.$strip>]>;
+declare const renderSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    cfAccountId: z.ZodString;
+    cfAPIKey: z.ZodString;
+    mode: z.ZodLiteral<"cf">;
+}, z.core.$strip>, z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    puppeteerURL: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"puppeteer">;
+}, z.core.$strip>, z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodNumber>;
+    waitTimeout: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"custom">;
+}, z.core.$strip>]>, z.ZodObject<{
+    defaultWaitTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    waitTimeout: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    puppeteerURL: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    cfAccountId: z.ZodOptional<z.ZodString>;
+    cfAPIKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+type RenderConfig = z.infer<typeof renderSchema>;
+type StrictRenderConfig = z.infer<typeof strictRenderConfig>;
+declare class CFBrowserRendering implements ImageRender {
+    f: Fetch;
+    constructor(accountId: string, cfAPIKey: string, logger: Logger);
+    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>;
+type ImageRenderCreateOptions = StrictRenderConfig & {
+    logger: Logger;
+    render?: ImageRender;
+    browserGetter?: () => Promise<Browser>;
+};
+declare const getImageRender: (config: ImageRenderCreateOptions) => ImageRender;
+type CreateImageRenderOption = Parameters<typeof getImageRender>[0];
+
+declare class UserPreferenceStore {
+    private db;
+    private uid;
+    v: any;
+    constructor(db: DB, uid: string);
+    getUserPreference(uid: string): 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;
+    private constructor();
+    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 S3Config {
+    s3AccessKey: string;
+    s3SecretKey: string;
+    endpoint: string;
+    region?: string;
+    bucketName: string;
+    keyPrefix?: string;
+    baseURL: string;
+}
+declare const strictS3ConfigSchema: z.ZodObject<{
+    s3AccessKey: z.ZodString;
+    s3SecretKey: z.ZodString;
+    endpoint: z.ZodString;
+    baseURL: z.ZodString;
+    bucketName: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const s3ConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    s3AccessKey: z.ZodString;
+    s3SecretKey: z.ZodString;
+    endpoint: z.ZodString;
+    baseURL: z.ZodString;
+    bucketName: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    enabled: z.ZodLiteral<false>;
+}, z.core.$strip>]>;
+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>;
+}
+
+type Services = {
+    db: DB;
+    api: APIService;
+    render: RenderService;
+    i18n: I18nService;
+    s3: S3Service;
+};
+declare class CommandBuilder<T, OPT = unknown> extends CommandBuilder$1<Services, Config, OPT> {
+}
+type CmdContext<O = unknown> = CmdContext$1<Services, Config, O>;
+type Command<O = unknown> = Command$1<Services, Config, O>;
+
+declare const getScheduleTasks: (config: Config) => {
+    name: string;
+    handler: (c: EventHandlerCtx<Services, Config>) => Promise<void>;
+    cron: string;
+    enabled: boolean;
+}[];
+
+declare const botCommands: () => Command[];
+
+interface WSHandler {
+    wsUrl: string;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onEvent?: (event: any) => void;
+}
+
+declare class BeatleaderWSHandler<T> implements WSHandler {
+    private readonly logger;
+    private render;
+    private agentService;
+    wsUrl: string;
+    private db;
+    config: Config;
+    constructor(db: DB, render: RenderService, logger: Logger, config: Config, agentService: AgentService);
+    onOpen(): void;
+    onClose(): void;
+    onEvent(event: any): Promise<void>;
+}
+
+declare class BeatSaverWSHandler<T> implements WSHandler {
+    private readonly logger;
+    private render;
+    private agentService;
+    wsUrl: string;
+    private db;
+    config: Config;
+    constructor(db: DB, render: RenderService, logger: Logger, config: Config, agentService: AgentService);
+    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 getBot: (config: Config) => {
+    commands: Command[];
     schedule: {
         name: string;
-        handler: <T_1>(c: ScheduleTaskCtx<T_1>) => Promise<void>;
+        handler: (c: EventHandlerCtx<Services, Config>) => Promise<void>;
         cron: string;
-        enable: boolean;
+        enabled: boolean;
     }[];
 };
 
-export { Command, Config, getBot };
+export { APIService, type Account, type AgentService, BeatSaverWSHandler, BeatleaderWSHandler, CFBrowserRendering, type Channel, type CmdContext, type Command, CommandBuilder, type Config, type CreateImageRenderOption, type DB, DecodeInfo, DecodeNotes, I18nService, type ISession, type ImageRender, type Logger, NoteEventType, type PassiveSession, Platform, type PositiveSession, type Preference, type RenderOptions$1 as PuppeteerOptions, PuppeteerRendering, RemoteBrowserGetter, type RenderConfig, RenderService, type S3Config, S3Service, type Services, type SessionAgent, type SubDetailWithGroupRes, type SubInfoRes, type SubWithGroupRes, type Subscription, type SubscriptionMember, type User, type WSHandler, botCommands, checkBSORFile, configSchema, convertDiff, decode, decodeAsync, getBot, getImageRender, getScheduleTasks, handleWSEventWithCache, parsePlatform, renderSchema, s3ConfigSchema, sleep, strictS3ConfigSchema };