lxns-rhythm-api 0.1.4 → 0.1.9

package/dist/index.d.ts

@@ -1,5 +1,176 @@
 import { KyInstance } from 'ky';
 
+interface Notes$1 {
+    total: number;
+    tap: number;
+    hold: number;
+    slide: number;
+    air: number;
+    flick: number;
+}
+declare enum LevelIndex$1 {
+    BASIC = 0,
+    ADVANCED = 1,
+    EXPERT = 2,
+    MASTER = 3,
+    ULTIMA = 4,
+    WORLDS_END = 5
+}
+interface ClassEmblem {
+    base: number;
+    medal: number;
+}
+type ClearType = "catastrophy" | "absolute" | "brave" | "hard" | "clear" | "failed";
+type RankType = "sssp" | "sss" | "ssp" | "ss" | "sp" | "s" | "aaa" | "aa" | "a" | "bbb" | "bb" | "b" | "c" | "d";
+type FullComboType = "alljusticecritical" | "alljustice" | "fullcombo";
+type FullChainType = "fullchain" | "fullchain2";
+type TrophyColor = "normal" | "copper" | "silver" | "gold" | "platinum" | "rainbow" | "image";
+type SongType$1 = string;
+interface SongDifficulty$1 {
+    difficulty: LevelIndex$1;
+    level: string;
+    level_value: number;
+    note_designer: string;
+    version: number;
+    notes?: Notes$1;
+    origin_id?: number;
+    kanji?: string;
+    star?: number;
+}
+interface Song$2 {
+    id: number;
+    title: string;
+    artist: string;
+    genre: string;
+    bpm: number;
+    map?: string;
+    version: number;
+    rights?: string;
+    disabled?: boolean;
+    locked?: boolean;
+    difficulties: SongDifficulty$1[];
+    aliases?: string[];
+}
+interface Genre$1 {
+    id: number;
+    genre: string;
+}
+interface Version$1 {
+    id: number;
+    title: string;
+    version: number;
+}
+interface Alias$1 {
+    song_id: number;
+    aliases: string[];
+}
+interface Player$1 {
+    name: string;
+    level: number;
+    rating: number;
+    rating_possession: string;
+    friend_code: number;
+    class_emblem: ClassEmblem;
+    reborn_count: number;
+    over_power: number;
+    over_power_progress: number;
+    currency: number;
+    total_currency: number;
+    total_play_count: number;
+    team?: Team;
+    trophy?: Trophy$1;
+    character?: Character;
+    name_plate?: NamePlate$1;
+    map_icon?: MapIcon;
+    upload_time?: string;
+}
+interface Team {
+    id: number;
+    name: string;
+}
+interface Collection$1 {
+    id: number;
+    name: string;
+    color?: TrophyColor;
+    level?: number;
+    required?: CollectionRequired$1[];
+}
+interface CollectionRequired$1 {
+    difficulties?: LevelIndex$1[];
+    rank?: RankType;
+    clear?: ClearType;
+    full_combo?: FullComboType;
+    full_chain?: FullChainType;
+    songs?: CollectionRequiredSong$1[];
+    completed?: boolean;
+}
+interface CollectionRequiredSong$1 {
+    id: number;
+    title: string;
+    type: SongType$1;
+    completed?: boolean;
+    completed_difficulties?: LevelIndex$1[];
+}
+interface Score$1 {
+    id: number;
+    song_name?: string;
+    level?: string;
+    level_index: LevelIndex$1;
+    score: number;
+    over_power?: number;
+    clear?: ClearType;
+    rank?: RankType;
+    full_combo?: FullComboType;
+    full_chain?: FullChainType;
+    chain?: number;
+    rating?: number;
+    type: SongType$1;
+    play_time?: string;
+    upload_time?: string;
+    last_played_time?: string;
+}
+interface SimpleScore$1 {
+    id: number;
+    song_name: string;
+    level: string;
+    level_index: LevelIndex$1;
+    clear: ClearType;
+    rank: RankType;
+    full_combo?: FullComboType;
+    full_chain?: FullChainType;
+    type: SongType$1;
+}
+interface RatingTrend$1 {
+    rating: number;
+    bests_rating: number;
+    selections_rating: number;
+    recents_rating?: number;
+    new_bests_rating?: number;
+    date: string;
+}
+interface Trophy$1 extends Collection$1 {
+}
+interface Character extends Collection$1 {
+}
+interface NamePlate$1 extends Collection$1 {
+}
+interface MapIcon extends Collection$1 {
+}
+type AssetType$1 = "character" | "trophy" | "plate" | "icon" | "jacket" | "music";
+
+type models$1_Character = Character;
+type models$1_ClassEmblem = ClassEmblem;
+type models$1_ClearType = ClearType;
+type models$1_FullChainType = FullChainType;
+type models$1_FullComboType = FullComboType;
+type models$1_MapIcon = MapIcon;
+type models$1_RankType = RankType;
+type models$1_Team = Team;
+type models$1_TrophyColor = TrophyColor;
+declare namespace models$1 {
+  export { type Alias$1 as Alias, type AssetType$1 as AssetType, type models$1_Character as Character, type models$1_ClassEmblem as ClassEmblem, type models$1_ClearType as ClearType, type Collection$1 as Collection, type CollectionRequired$1 as CollectionRequired, type CollectionRequiredSong$1 as CollectionRequiredSong, type models$1_FullChainType as FullChainType, type models$1_FullComboType as FullComboType, type Genre$1 as Genre, LevelIndex$1 as LevelIndex, type models$1_MapIcon as MapIcon, type NamePlate$1 as NamePlate, type Notes$1 as Notes, type Player$1 as Player, type models$1_RankType as RankType, type RatingTrend$1 as RatingTrend, type Score$1 as Score, type SimpleScore$1 as SimpleScore, type Song$2 as Song, type SongDifficulty$1 as SongDifficulty, type SongType$1 as SongType, type models$1_Team as Team, type Trophy$1 as Trophy, type models$1_TrophyColor as TrophyColor, type Version$1 as Version };
+}
+
 interface Notes {
     total: number;
     tap: number;
@@ -285,97 +456,144 @@ declare namespace models {
   export { type models_Alias as Alias, type models_AssetType as AssetType, type models_BuddyNotes as BuddyNotes, type models_Collection as Collection, type models_CollectionGenre as CollectionGenre, type models_CollectionRequired as CollectionRequired, type models_CollectionRequiredSong as CollectionRequiredSong, type models_FCType as FCType, type models_FSType as FSType, type models_Frame as Frame, type models_Genre as Genre, type models_Icon as Icon, models_LevelIndex as LevelIndex, type models_NamePlate as NamePlate, type models_Notes as Notes, type models_Player as Player, type models_RateType as RateType, type models_RatingTrend as RatingTrend, type models_Score as Score, type models_SimpleScore as SimpleScore, type Song$1 as Song, type models_SongDifficulties as SongDifficulties, type models_SongDifficulty as SongDifficulty, type models_SongDifficultyUtage as SongDifficultyUtage, type models_SongType as SongType, type models_Trophy as Trophy, type models_Version as Version };
 }
 
-interface SongList {
-    songs: Song$1[];
-    genres: Genre[];
-    versions: Version[];
-}
-interface AliasList {
-    aliases: Alias[];
+interface Bests$1 {
+    bests: Score$1[];
+    selections: Score$1[];
+    new_bests: Score$1[];
+}
+type RecentList$1 = Score$1[];
+type BestScoreList$1 = SimpleScore$1[];
+type Heatmap$1 = Record<string, number>;
+type TrendList$1 = RatingTrend$1[];
+type ScoreHistory$1 = Score$1[];
+
+/**
+ * chunithm 开发者 API
+ */
+declare class ChunithmDevApi {
+    readonly http: KyInstance;
+    constructor(http: KyInstance);
+    /**
+     * 创建或修改玩家信息
+     */
+    postPlayer(body: Player$1): Promise<Player$1>;
+    /**
+     * 获取玩家信息（通过好友码）
+     */
+    getPlayer(friendCode: number): Promise<Player$1>;
+    /**
+     * 获取玩家信息（通过 QQ 号）
+     */
+    getPlayerByQQ(qq: number): Promise<Player$1>;
+    /**
+     * 获取 Best 30（old 15 + new 15）
+     */
+    getBests(friendCode: number): Promise<Bests$1>;
+    /**
+     * 获取玩家缓存谱面的最佳成绩
+     */
+    getBest(friendCode: number, options: {
+        songId?: number;
+        songName?: string;
+        levelIndex?: LevelIndex$1;
+    }): Promise<Score$1>;
+    /**
+     * 获取玩家缓存的所有最佳成绩（简化）
+     */
+    getAllBestScores(friendCode: number): Promise<BestScoreList$1>;
+    /**
+     * 获取 Recent 50
+     */
+    getRecents(friendCode: number): Promise<RecentList$1>;
+    /**
+     * 获取成绩游玩历史记录
+     */
+    getScoreHistory(friendCode: number, options?: {
+        songId?: number;
+        levelIndex?: LevelIndex$1;
+    }): Promise<ScoreHistory$1>;
+    /**
+     * 成绩上传热力图
+     */
+    getHeatmap(friendCode: number): Promise<Heatmap$1>;
+    /**
+     * Rating 趋势
+     */
+    getTrend(friendCode: number, version?: number): Promise<TrendList$1>;
+    /**
+     * 获取玩家收藏品进度
+     */
+    getCollectionProgress(friendCode: number, collectionType: "trophy" | "character" | "plate" | "icon", collectionId: number): Promise<Collection$1>;
+    /**
+     * 上传玩家成绩
+     */
+    postScores(friendCode: number, scores: Score$1[]): Promise<unknown>;
+    /**
+     * 通过 NET 的 HTML 源代码上传玩家数据
+     */
+    postHtml(friendCode: number, htmlSource: string): Promise<unknown>;
 }
-interface CollectionGenreList {
-    collectionGenres: CollectionGenre[];
+
+type PlayerScores$1 = Score$1[];
+
+/**
+ * chunithm 个人 API（需用户身份）
+ */
+declare class ChunithmPersonalApi {
+    readonly http: KyInstance;
+    constructor(http: KyInstance);
+    /**
+     * 获取玩家信息
+     * GET /api/v0/user/chunithm/player
+     */
+    getPlayer(): Promise<Player$1>;
+    /**
+     * 获取玩家所有成绩
+     * GET /api/v0/user/chunithm/player/scores
+     */
+    getScores(): Promise<PlayerScores$1>;
+    /**
+     * 上传玩家成绩
+     * POST /api/v0/user/chunithm/player/scores
+     */
+    postScores(scores: Score$1[]): Promise<unknown>;
 }
 
-declare class Song implements Song$1 {
-    readonly id: Song$1["id"];
-    readonly title: Song$1["title"];
-    readonly artist: Song$1["artist"];
-    readonly genre: Song$1["genre"];
-    readonly version: Song$1["version"];
-    readonly bpm: Song$1["bpm"];
-    readonly difficulties: Song$1["difficulties"];
-    readonly locked: boolean;
-    readonly disabled: boolean;
-    readonly rights: Song$1["rights"];
-    constructor(song: Song$1);
-    get standard(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficulty> | null;
-    get dx(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficulty> | null;
-    get utage(): Record<"basic" | "advanced" | "expert" | "master" | "remaster", SongDifficultyUtage> | null;
+interface SongList$1 {
+    songs: Song$2[];
+    genres: Genre$1[];
+    versions: Version$1[];
+}
+interface AliasList$1 {
+    aliases: Alias$1[];
 }
 
 /**
- * maimai 公共 API
+ * chunithm 公共 API
  */
-declare class MaimaiPublicApi {
-    private readonly http;
+declare class ChunithmPublicApi {
+    readonly http: KyInstance;
     constructor(http: KyInstance);
     /**
      * 获取歌曲列表
-     * @param version 版本，不填写遵循api默认行为
-     * @param notes 是否包含谱面信息，不填写遵循api默认行为
-     * @returns 歌曲列表
      */
-    getSongList(version?: number, notes?: boolean): Promise<SongList>;
+    getSongList(version?: number, notes?: boolean): Promise<SongList$1>;
     /**
      * 获取歌曲信息
-     * @param id 歌曲 ID
-     * @returns 歌曲信息
      */
-    getSong(id: number): Promise<Song>;
+    getSong(id: number, version?: number): Promise<Song$2>;
     /**
      * 获取歌曲别名列表
-     * @returns 歌曲别名列表
      */
-    getAliasList(): Promise<AliasList>;
+    getAliasList(): Promise<AliasList$1>;
     /**
      * 获取收藏品列表
-     * @param collectionType trophy | icon | plate | frame
-     * @param options.version 版本，不填写遵循api默认行为
-     * @param options.required 是否包含曲目需求，默认值为 false
-     * @returns 收藏品列表
      */
-    getCollectionList(collectionType: "trophy" | "icon" | "plate" | "frame", options?: {
-        version?: number;
-        required?: boolean;
-    }): Promise<Collection[] | undefined>;
+    getCollectionList(collectionType: "trophy" | "character" | "plate" | "icon", version?: number): Promise<Collection$1[] | undefined>;
     /**
      * 获取收藏品信息
-     * @param collectionType trophy | icon | plate | frame
-     * @param id 收藏品 ID
-     * @param options.version 版本，不填写遵循api默认行为
-     * @returns 收藏品信息
-     */
-    getCollectionInfo(collectionType: "trophy" | "icon" | "plate" | "frame", id: number, options?: {
-        version?: number;
-    }): Promise<Collection>;
-    /**
-     * 获取收藏品分类列表
-     * @param options.version 版本，不填写遵循api默认行为
-     * @returns 收藏品分类列表
      */
-    getCollectionGenreList(options?: {
-        version?: number;
-    }): Promise<CollectionGenreList>;
-    /**
-     * 获取收藏品分类信息
-     * @param id 收藏品分类 ID
-     * @param options.version 版本，不填写遵循api默认行为
-     * @returns 收藏品分类信息
-     */
-    getCollectionGenreInfo(id: number, options?: {
-        version?: number;
-    }): Promise<CollectionGenre>;
+    getCollectionInfo(collectionType: "trophy" | "character" | "plate" | "icon", id: number, version?: number): Promise<Collection$1>;
 }
 
 interface Bests {
@@ -394,7 +612,7 @@ type ScoreHistory = Score[];
  * maimai 开发者 API（路径风格，与文档一致，不使用查询参数）
  */
 declare class MaimaiDevApi {
-    private readonly http;
+    readonly http: KyInstance;
     constructor(http: KyInstance);
     /**
      * 创建或修改玩家信息
@@ -486,7 +704,7 @@ type PlayerScores = Score[];
  * maimai 个人 API（需用户身份，路径遵循文档）
  */
 declare class MaimaiPersonalApi {
-    private readonly http;
+    readonly http: KyInstance;
     constructor(http: KyInstance);
     /**
      * 获取玩家信息
@@ -509,29 +727,145 @@ declare class MaimaiPersonalApi {
     postScores(scores: Score[]): Promise<unknown>;
 }
 
-type LxnsApiClientTokens = Omit<LxnsApiClientOptions, "baseURL">;
-type Flags = Readonly<LxnsApiClientTokens>;
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type IfDefined<T, Then, Else = {}> = [T] extends [NonNullable<T>] ? Then : Else;
-type MaiMai = {
-    public: MaimaiPublicApi;
-    dev?: MaimaiDevApi;
-    personal?: MaimaiPersonalApi;
-    getAsset: (type: AssetType, id: number) => Promise<Buffer>;
+type DifficultyMap<T> = {
+    0: T;
+    1: T;
+    2: T;
+    3: T;
+    4?: T;
+    basic: T;
+    advanced: T;
+    expert: T;
+    master: T;
+    remaster?: T;
 };
-type MaiMaiOf<O extends Flags> = Simplify<Omit<MaiMai, "dev" | "personal"> & IfDefined<O["devAccessToken"], {
-    dev: MaimaiDevApi;
-}> & IfDefined<O["personalAccessToken"], {
-    personal: MaimaiPersonalApi;
-}>>;
+declare class Song implements Song$1 {
+    readonly id: Song$1["id"];
+    readonly title: Song$1["title"];
+    readonly artist: Song$1["artist"];
+    readonly genre: Song$1["genre"];
+    readonly version: Song$1["version"];
+    readonly bpm: Song$1["bpm"];
+    readonly difficulties: Song$1["difficulties"];
+    readonly locked: boolean;
+    readonly disabled: boolean;
+    readonly rights: Song$1["rights"];
+    constructor(song: Song$1);
+    get standard(): DifficultyMap<SongDifficulty> | null;
+    get dx(): DifficultyMap<SongDifficulty> | null;
+    get utage(): SongDifficultyUtage[] | null;
+}
+
+interface SongList {
+    songs: Song$1[];
+    genres: Genre[];
+    versions: Version[];
+}
+interface AliasList {
+    aliases: Alias[];
+}
+interface CollectionGenreList {
+    collectionGenres: CollectionGenre[];
+}
 
-interface LxnsApiClientOptions {
+/**
+ * maimai 公共 API
+ */
+declare class MaimaiPublicApi {
+    readonly http: KyInstance;
+    constructor(http: KyInstance);
+    /**
+     * 获取歌曲列表
+     * @param version 版本，不填写遵循api默认行为
+     * @param notes 是否包含谱面信息，不填写遵循api默认行为
+     * @returns 歌曲列表
+     */
+    getSongList(version?: number, notes?: boolean): Promise<SongList>;
+    /**
+     * 获取歌曲信息
+     * @param id 歌曲 ID
+     * @returns 歌曲信息
+     */
+    getSong(id: number): Promise<Song>;
+    /**
+     * 获取歌曲别名列表
+     * @returns 歌曲别名列表
+     */
+    getAliasList(): Promise<AliasList>;
+    /**
+     * 获取收藏品列表
+     * @param collectionType trophy | icon | plate | frame
+     * @param options.version 版本，不填写遵循api默认行为
+     * @param options.required 是否包含曲目需求，默认值为 false
+     * @returns 收藏品列表
+     */
+    getCollectionList(collectionType: "trophy" | "icon" | "plate" | "frame", options?: {
+        version?: number;
+        required?: boolean;
+    }): Promise<Collection[] | undefined>;
+    /**
+     * 获取收藏品信息
+     * @param collectionType trophy | icon | plate | frame
+     * @param id 收藏品 ID
+     * @param options.version 版本，不填写遵循api默认行为
+     * @returns 收藏品信息
+     */
+    getCollectionInfo(collectionType: "trophy" | "icon" | "plate" | "frame", id: number, options?: {
+        version?: number;
+    }): Promise<Collection>;
+    /**
+     * 获取收藏品分类列表
+     * @param options.version 版本，不填写遵循api默认行为
+     * @returns 收藏品分类列表
+     */
+    getCollectionGenreList(options?: {
+        version?: number;
+    }): Promise<CollectionGenreList>;
+    /**
+     * 获取收藏品分类信息
+     * @param id 收藏品分类 ID
+     * @param options.version 版本，不填写遵循api默认行为
+     * @returns 收藏品分类信息
+     */
+    getCollectionGenreInfo(id: number, options?: {
+        version?: number;
+    }): Promise<CollectionGenre>;
+}
+
+type DataValue = Record<string, unknown> | Array<unknown> | null;
+type ApiResponse<TData = DataValue> = {
+    success: boolean;
+    code: number;
+    message?: string;
+    data?: TData;
+};
+interface LxnsApiClientOptions$1 {
     personalAccessToken?: string;
     devAccessToken?: string;
     baseURL?: string;
 }
+type LxnsApiClientTokenFlags = Readonly<Omit<LxnsApiClientOptions$1, "baseURL">>;
+type IfDefined<T, Then, Else = object> = [T] extends [NonNullable<T>] ? Then : Else;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+type GameApi<O extends LxnsApiClientTokenFlags, TPublic, TDev, TPersonal, TExtra extends object = object> = Simplify<{
+    public: TPublic;
+} & TExtra & IfDefined<O["devAccessToken"], {
+    dev: TDev;
+}> & IfDefined<O["personalAccessToken"], {
+    personal: TPersonal;
+}>>;
+type MaimaiApiExtra = {
+    getAsset: (type: AssetType, id: number) => Promise<Uint8Array>;
+};
+type MaimaiApiOf<O extends LxnsApiClientTokenFlags> = GameApi<O, MaimaiPublicApi, MaimaiDevApi, MaimaiPersonalApi, MaimaiApiExtra>;
+type ChunithmApiExtra = {
+    getAsset: (type: AssetType$1, id: number) => Promise<Uint8Array>;
+};
+type ChunithmApiOf<O extends LxnsApiClientTokenFlags> = GameApi<O, ChunithmPublicApi, ChunithmDevApi, ChunithmPersonalApi, ChunithmApiExtra>;
+
+type LxnsApiClientOptions = LxnsApiClientOptions$1;
 declare class LxnsApiClient<O extends LxnsApiClientOptions> {
     config: LxnsApiClientOptions & {
         baseURL: string;
@@ -539,8 +873,27 @@ declare class LxnsApiClient<O extends LxnsApiClientOptions> {
     /**
      * maimai API
      */
-    readonly maimai: MaiMaiOf<O>;
+    readonly maimai: MaimaiApiOf<O>;
+    /**
+     * chunithm API
+     */
+    readonly chunithm: ChunithmApiOf<O>;
+    private static readonly BASE_OPTIONS;
+    private mountGameApi;
     constructor(config?: Readonly<O>);
 }
 
-export { LxnsApiClient, models as MaimaiModels };
+declare class LxnsApiError extends Error {
+    readonly code: number;
+    readonly status?: number;
+    readonly success: boolean;
+    readonly data?: DataValue;
+    constructor(payload: ApiResponse, status?: number);
+}
+declare function isLxnsApiError(error: unknown): error is LxnsApiError;
+declare function isNotFoundError(error: unknown): error is LxnsApiError;
+declare function isAuthError(error: unknown): error is LxnsApiError;
+declare function isRateLimitError(error: unknown): error is LxnsApiError;
+declare function isServerError(error: unknown): error is LxnsApiError;
+
+export { models$1 as ChunithmModels, LxnsApiClient, LxnsApiError, models as MaimaiModels, isAuthError, isLxnsApiError, isNotFoundError, isRateLimitError, isServerError };