neteasecli 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wangwalk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,175 @@
+# neteasecli
+
+Netease Cloud Music CLI / 网易云音乐命令行工具
+
+Search, play, download, and manage your library — all from the terminal with structured JSON output for scripting and AI agent integration.
+
+## Features
+
+- Search tracks, albums, artists, playlists
+- Playback via [mpv](https://mpv.io/) with IPC control (play/pause/stop/seek/volume/repeat)
+- Track info, streaming URLs, lyrics, download
+- Library management (liked tracks, recent history)
+- Playlist browsing
+- Browser cookie import from Chrome, Edge, Firefox, Safari via [sweet-cookie](https://github.com/nicolo-ribaudo/sweet-cookie)
+- Multi-profile support for multiple accounts
+- Three output modes: colorized human-readable, JSON, plain text
+- Debug/verbose logging (`-v`, `-d`)
+- Cross-platform: macOS, Linux, Windows
+
+## Why Cookies?
+
+Netease Cloud Music has no public API. The unofficial API endpoints require encrypted requests and valid session cookies. Instead of implementing a fragile login flow (SMS/QR code), neteasecli imports cookies directly from your browser:
+
+- **Multi-browser** — Chrome, Edge, Firefox, Safari (auto-detected)
+- **No credentials stored** — reads browser's encrypted cookie DB via OS keychain
+- **No captcha** — skip SMS verification entirely
+- **Always fresh** — re-run `auth login` anytime to refresh
+- **One command** — `neteasecli auth login` and you're in
+
+## Install / 安装
+
+```bash
+# Run without installing / 免安装运行
+npx neteasecli search track "Jay Chou"
+
+# Install globally / 全局安装
+npm install -g neteasecli
+```
+
+## Quick Start / 快速开始
+
+```bash
+neteasecli auth login                    # Import cookies from Chrome
+neteasecli search track "Sunny Day"      # Search
+neteasecli track play 185868             # Play (requires mpv)
+neteasecli player pause                  # Pause/resume
+neteasecli player stop                   # Stop
+```
+
+## Commands / 命令
+
+### auth
+
+```bash
+neteasecli auth login              # Import cookies from browser / 从浏览器导入 Cookie
+neteasecli auth login --profile X  # Specify Chrome/Edge profile / 指定 Chrome/Edge Profile
+neteasecli auth check              # Check login status / 检查登录状态
+neteasecli auth logout             # Logout / 登出
+```
+
+### search
+
+```bash
+neteasecli search track <query>    # Search tracks / 搜索歌曲
+neteasecli search album <query>    # Search albums / 搜索专辑
+neteasecli search playlist <query> # Search playlists / 搜索歌单
+neteasecli search artist <query>   # Search artists / 搜索歌手
+```
+
+Options: `-l, --limit <n>` (default 20), `-o, --offset <n>` (default 0)
+
+### track
+
+```bash
+neteasecli track detail <id>       # Track metadata / 歌曲详情
+neteasecli track url <id>          # Streaming URL / 播放链接
+neteasecli track lyric <id>        # Lyrics / 歌词
+neteasecli track download <id>     # Download / 下载
+neteasecli track play <id>         # Play via mpv / 用 mpv 播放
+```
+
+Options: `-q, --quality <level>` standard | higher | exhigh (default) | lossless | hires
+
+### player
+
+Requires [mpv](https://mpv.io/). / 需要安装 [mpv](https://mpv.io/)。
+
+```bash
+neteasecli player status           # Current playback status / 播放状态
+neteasecli player pause            # Toggle pause/resume / 暂停或继续
+neteasecli player stop             # Stop playback / 停止播放
+neteasecli player seek <seconds>   # Seek relative (e.g. 10, -10) / 快进快退
+neteasecli player seek 30 --absolute  # Seek to absolute position / 跳转到指定位置
+neteasecli player volume [0-150]   # Get or set volume / 音量
+neteasecli player repeat [on|off]  # Toggle or set repeat / 单曲循环
+```
+
+### library
+
+```bash
+neteasecli library liked           # Liked tracks / 喜欢的音乐
+neteasecli library like <id>       # Like a track / 收藏
+neteasecli library unlike <id>     # Unlike / 取消收藏
+neteasecli library recent          # Recently played / 最近播放
+```
+
+### playlist
+
+```bash
+neteasecli playlist list           # My playlists / 我的歌单
+neteasecli playlist detail <id>    # Playlist tracks / 歌单详情
+```
+
+## Global Options / 全局选项
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Force JSON output (default when piped) / 强制 JSON 输出 |
+| `--plain` | Plain text output (tab-separated) / 纯文本输出 |
+| `--pretty` | Pretty-print JSON / 格式化 JSON |
+| `--quiet` | Suppress output / 静默模式 |
+| `--no-color` | Disable colors / 禁用颜色 |
+| `--profile <name>` | Account profile (default: "default") / 账号配置 |
+| `-v, --verbose` | Verbose output / 详细输出 |
+| `-d, --debug` | Debug output (implies --verbose) / 调试输出 |
+| `--timeout <seconds>` | Request timeout (default: 30) / 请求超时秒数 |
+
+## Output Modes / 输出模式
+
+| Mode | When | Description |
+|------|------|-------------|
+| Human | TTY (default) | Colorized, readable / 彩色可读 |
+| JSON | Piped or `--json` | Structured `{ success, data, error }` / 结构化 JSON |
+| Plain | `--plain` | Tab-separated, scriptable / 制表符分隔 |
+
+```bash
+# Colorized output in terminal / 终端彩色输出
+neteasecli search track "Jay Chou"
+
+# JSON for scripting / JSON 用于脚本
+neteasecli --json search track "Jay Chou"
+neteasecli search track "Jay Chou" | jq '.data.tracks[0]'
+
+# Plain text for cut/awk / 纯文本用于文本处理
+neteasecli --plain search track "Jay Chou" | cut -f1,2
+```
+
+Exit codes: `0` success, `1` general error, `2` auth error, `3` network error.
+
+## Multi-Profile / 多账号
+
+```bash
+neteasecli --profile work auth login    # Login with "work" profile
+neteasecli --profile work library liked  # Use "work" profile
+neteasecli auth login                    # Default profile
+```
+
+Profiles are stored in `~/.config/neteasecli/profiles/<name>/`.
+
+## Requirements / 环境要求
+
+- Node.js >= 22
+- Chrome, Edge, Firefox, or Safari (for cookie import / 用于导入 Cookie)
+- [mpv](https://mpv.io/) (optional, for playback / 可选，用于播放)
+- macOS, Linux, or Windows
+
+## Legal / 免责
+
+This tool uses unofficial Netease Cloud Music API endpoints. Use responsibly and in accordance with Netease's Terms of Service.
+
+本工具使用非官方网易云音乐 API，请合理使用并遵守网易云音乐服务条款。
+
+## License
+
+MIT

package/dist/api/client.d.ts

@@ -0,0 +1,19 @@
+export type CryptoType = 'weapi' | 'linuxapi' | 'eapi';
+export interface RequestOptions {
+    crypto?: CryptoType;
+    url?: string;
+}
+export declare class ApiClient {
+    private client;
+    private readonly sDeviceId;
+    private readonly nmtid;
+    private sessionCookies;
+    constructor();
+    updateTimeout(ms: number): void;
+    private collectCookies;
+    private getCookieHeader;
+    request<T>(endpoint: string, data?: object, options?: RequestOptions): Promise<T>;
+    download(url: string, destPath: string): Promise<void>;
+}
+export declare function setRequestTimeout(ms: number): void;
+export declare function getApiClient(): ApiClient;

package/dist/api/client.js

@@ -0,0 +1,157 @@
+import axios, { AxiosError } from 'axios';
+import * as crypto from 'crypto';
+import { weapi, linuxapi, eapi } from './crypto.js';
+import { getAuthManager } from '../auth/manager.js';
+import * as fs from 'fs';
+import * as http from 'http';
+import * as https from 'https';
+import { pipeline } from 'stream/promises';
+import { verbose, debug } from '../output/logger.js';
+// Force IPv4 to avoid IPv6 CDN hotlink protection issues
+const httpAgent = new http.Agent({ family: 4 });
+const httpsAgent = new https.Agent({ family: 4 });
+const BASE_URL = 'https://music.163.com';
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0';
+export class ApiClient {
+    client;
+    sDeviceId = `unknown-${Math.floor(Math.random() * 1000000)}`;
+    nmtid = crypto.randomBytes(16).toString('hex');
+    sessionCookies = {};
+    constructor() {
+        this.client = axios.create({
+            baseURL: BASE_URL,
+            timeout: requestTimeout,
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Referer: 'https://music.163.com',
+            },
+        });
+    }
+    updateTimeout(ms) {
+        this.client.defaults.timeout = ms;
+    }
+    collectCookies(response) {
+        const setCookieHeaders = response.headers['set-cookie'];
+        if (!setCookieHeaders)
+            return;
+        for (const header of setCookieHeaders) {
+            const match = header.match(/^([^=]+)=([^;]*)/);
+            if (match) {
+                this.sessionCookies[match[1]] = match[2];
+            }
+        }
+    }
+    getCookieHeader(endpoint) {
+        const authManager = getAuthManager();
+        const userCookies = authManager.getCookieString();
+        const parts = ['os=pc', `sDeviceId=${this.sDeviceId}`, '__remember_me=true'];
+        if (endpoint && endpoint.includes('login')) {
+            parts.push(`NMTID=${this.nmtid}`);
+        }
+        if (userCookies) {
+            parts.push(userCookies);
+        }
+        for (const [name, value] of Object.entries(this.sessionCookies)) {
+            parts.push(`${name}=${value}`);
+        }
+        return parts.join('; ');
+    }
+    async request(endpoint, data = {}, options = {}) {
+        const { crypto: cryptoType = 'weapi' } = options;
+        let url;
+        let postData;
+        const requestData = { ...data };
+        switch (cryptoType) {
+            case 'weapi': {
+                url = `/weapi${endpoint}`;
+                const encrypted = weapi(requestData);
+                postData = {
+                    params: encrypted.params,
+                    encSecKey: encrypted.encSecKey,
+                };
+                break;
+            }
+            case 'linuxapi': {
+                url = '/api/linux/forward';
+                const encrypted = linuxapi({
+                    method: 'POST',
+                    url: `${BASE_URL}/api${endpoint}`,
+                    params: requestData,
+                });
+                postData = { eparams: encrypted.eparams };
+                break;
+            }
+            case 'eapi': {
+                const eapiUrl = options.url || `/api${endpoint}`;
+                url = `/eapi${endpoint}`;
+                const encrypted = eapi(eapiUrl, requestData);
+                postData = { params: encrypted.params };
+                break;
+            }
+        }
+        verbose(`${cryptoType.toUpperCase()} ${endpoint}`);
+        debug(`POST ${url}`);
+        try {
+            const response = await this.client.post(url, new URLSearchParams(postData).toString(), {
+                headers: {
+                    Cookie: this.getCookieHeader(endpoint),
+                },
+            });
+            this.collectCookies(response);
+            const responseData = response.data;
+            debug(`Response code: ${responseData.code ?? 200}`);
+            if (responseData.code && responseData.code !== 200) {
+                const msg = responseData.message || responseData.msg || 'Unknown error';
+                throw new Error(`${msg} (code: ${responseData.code})`);
+            }
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof AxiosError) {
+                if (error.response)
+                    this.collectCookies(error.response);
+                debug(`HTTP error: ${error.response?.status ?? error.code}`);
+                if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+                    throw new Error('Network connection failed');
+                }
+                if (error.response?.status === 401) {
+                    throw new Error('Authentication failed, please re-login');
+                }
+                if (error.response?.status === 403) {
+                    throw new Error('Access denied, login required or cookie expired');
+                }
+                throw new Error(`Request failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async download(url, destPath) {
+        verbose(`Downloading ${url}`);
+        const response = await axios.get(url, {
+            responseType: 'stream',
+            timeout: 120000,
+            httpAgent,
+            httpsAgent,
+            headers: {
+                'User-Agent': USER_AGENT,
+                Referer: 'https://music.163.com/',
+            },
+        });
+        await pipeline(response.data, fs.createWriteStream(destPath));
+    }
+}
+let requestTimeout = 30000;
+export function setRequestTimeout(ms) {
+    requestTimeout = ms;
+    if (clientInstance) {
+        clientInstance.updateTimeout(ms);
+    }
+}
+let clientInstance = null;
+export function getApiClient() {
+    if (!clientInstance) {
+        clientInstance = new ApiClient();
+    }
+    return clientInstance;
+}

package/dist/api/crypto.d.ts

@@ -0,0 +1,13 @@
+export interface WeapiResult {
+    params: string;
+    encSecKey: string;
+}
+export declare function weapi(data: object): WeapiResult;
+export interface LinuxapiResult {
+    eparams: string;
+}
+export declare function linuxapi(data: object): LinuxapiResult;
+export interface EapiResult {
+    params: string;
+}
+export declare function eapi(url: string, data: object): EapiResult;

package/dist/api/crypto.js

@@ -0,0 +1,59 @@
+import * as crypto from 'crypto';
+const IV = '0102030405060708';
+const PRESET_KEY = '0CoJUm6Qyw8W8jud';
+const PUBLIC_KEY = '-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgtQn2JZ34ZC28NWYpAUd98iZ37BUrX/aKzmFbt7clFSs6sXqHauqKWqdtLkF2KexO40H1YTX8z2lSgBBOAxLsvaklV8k4cBFK9snQXE9/DDaFt6Rr7iVZMldczhC0JNgTz+SHXT6CBHuX3e9SdB1Ua44oncaTWz7OBGLbCiK45wIDAQAB\n-----END PUBLIC KEY-----';
+const EAPI_KEY = 'e82ckenh8dichen8';
+const LINUX_API_KEY = 'rFgB&h#%2?^eDg:Q';
+function createSecretKey(size) {
+    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let key = '';
+    for (let i = 0; i < size; i++) {
+        key += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return key;
+}
+function aesEncrypt(text, key, iv = IV) {
+    const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
+    let encrypted = cipher.update(text, 'utf8', 'base64');
+    encrypted += cipher.final('base64');
+    return encrypted;
+}
+function rsaEncrypt(text, pubKey) {
+    const reversedText = text.split('').reverse().join('');
+    const buffer = Buffer.alloc(128, 0);
+    const textBuffer = Buffer.from(reversedText);
+    textBuffer.copy(buffer, 128 - textBuffer.length);
+    const encrypted = crypto.publicEncrypt({
+        key: pubKey,
+        padding: crypto.constants.RSA_NO_PADDING,
+    }, buffer);
+    return encrypted.toString('hex');
+}
+function md5(text) {
+    return crypto.createHash('md5').update(text).digest('hex');
+}
+export function weapi(data) {
+    const text = JSON.stringify(data);
+    const secretKey = createSecretKey(16);
+    const params1 = aesEncrypt(text, PRESET_KEY, IV);
+    const params = aesEncrypt(params1, secretKey, IV);
+    const encSecKey = rsaEncrypt(secretKey, PUBLIC_KEY);
+    return { params, encSecKey };
+}
+export function linuxapi(data) {
+    const text = JSON.stringify(data);
+    const cipher = crypto.createCipheriv('aes-128-ecb', LINUX_API_KEY, '');
+    let eparams = cipher.update(text, 'utf8', 'hex').toUpperCase();
+    eparams += cipher.final('hex').toUpperCase();
+    return { eparams };
+}
+export function eapi(url, data) {
+    const text = JSON.stringify(data);
+    const message = `nobody${url}use${text}md5forencrypt`;
+    const digest = md5(message);
+    const params = `${url}-36cd479b6b5-${text}-36cd479b6b5-${digest}`;
+    const cipher = crypto.createCipheriv('aes-128-ecb', EAPI_KEY, '');
+    let encrypted = cipher.update(params, 'utf8', 'hex').toUpperCase();
+    encrypted += cipher.final('hex').toUpperCase();
+    return { params: encrypted };
+}

package/dist/api/login.d.ts

@@ -0,0 +1,8 @@
+import type { AxiosResponse } from 'axios';
+import type { CookieData } from '../types/index.js';
+export declare function extractCookiesFromResponse(response: AxiosResponse): CookieData;
+export declare function sendCaptcha(phone: string, countrycode?: string): Promise<void>;
+export declare function loginByCaptcha(phone: string, captcha: string, countrycode?: string): Promise<{
+    cookies: CookieData;
+    profile: any;
+}>;

package/dist/api/login.js

@@ -0,0 +1,38 @@
+import { getApiClient } from './client.js';
+export function extractCookiesFromResponse(response) {
+    const cookies = {};
+    const setCookieHeaders = response.headers['set-cookie'];
+    if (!setCookieHeaders)
+        return cookies;
+    for (const header of setCookieHeaders) {
+        const match = header.match(/^([^=]+)=([^;]*)/);
+        if (match) {
+            const [, name, value] = match;
+            if (name === 'MUSIC_U' || name === '__csrf') {
+                cookies[name] = value;
+            }
+        }
+    }
+    return cookies;
+}
+export async function sendCaptcha(phone, countrycode = '86') {
+    const client = getApiClient();
+    await client.request('/sms/captcha/sent', {
+        cellphone: phone,
+        ctcode: countrycode,
+    }, { crypto: 'weapi' });
+}
+export async function loginByCaptcha(phone, captcha, countrycode = '86') {
+    const client = getApiClient();
+    const response = await client.requestRaw('/login/cellphone', {
+        phone,
+        captcha,
+        countrycode,
+        rememberLogin: 'true',
+    }, { crypto: 'weapi' });
+    const cookies = extractCookiesFromResponse(response);
+    if (!cookies.MUSIC_U) {
+        throw new Error('登录失败：未获取到 MUSIC_U cookie');
+    }
+    return { cookies, profile: response.data.profile };
+}

package/dist/api/playlist.d.ts

@@ -0,0 +1,3 @@
+import type { Playlist } from '../types/index.js';
+export declare function getPlaylistDetail(id: string): Promise<Playlist>;
+export declare function getUserPlaylists(uid?: string): Promise<Playlist[]>;

package/dist/api/playlist.js

@@ -0,0 +1,65 @@
+import { getApiClient } from './client.js';
+function transformTrack(track) {
+    const artists = track.ar || track.artists || [];
+    const album = track.al || track.album || { id: 0, name: '' };
+    return {
+        id: String(track.id),
+        name: track.name,
+        artists: artists.map((a) => ({ id: String(a.id), name: a.name })),
+        album: {
+            id: String(album.id),
+            name: album.name,
+            picUrl: album.picUrl,
+        },
+        duration: track.dt || track.duration || 0,
+        uri: `netease:track:${track.id}`,
+    };
+}
+export async function getPlaylistDetail(id) {
+    const client = getApiClient();
+    const response = await client.request('/v6/playlist/detail', {
+        id,
+        n: 100000,
+    });
+    const playlist = response.playlist;
+    return {
+        id: String(playlist.id),
+        name: playlist.name,
+        description: playlist.description,
+        coverUrl: playlist.coverImgUrl,
+        trackCount: playlist.trackCount,
+        creator: playlist.creator
+            ? {
+                id: String(playlist.creator.userId),
+                name: playlist.creator.nickname,
+            }
+            : undefined,
+        tracks: playlist.tracks?.map(transformTrack),
+    };
+}
+export async function getUserPlaylists(uid) {
+    const client = getApiClient();
+    let userId = uid;
+    if (!userId) {
+        const userInfo = await client.request('/nuser/account/get');
+        userId = String(userInfo.profile.userId);
+    }
+    const response = await client.request('/user/playlist', {
+        uid: userId,
+        limit: 1000,
+        offset: 0,
+    });
+    return response.playlist.map((p) => ({
+        id: String(p.id),
+        name: p.name,
+        description: p.description,
+        coverUrl: p.coverImgUrl,
+        trackCount: p.trackCount,
+        creator: p.creator
+            ? {
+                id: String(p.creator.userId),
+                name: p.creator.nickname,
+            }
+            : undefined,
+    }));
+}

package/dist/api/search.d.ts

@@ -0,0 +1,2 @@
+import type { SearchType, SearchResult } from '../types/index.js';
+export declare function search(keyword: string, type?: SearchType, limit?: number, offset?: number): Promise<SearchResult>;

package/dist/api/search.js

@@ -0,0 +1,82 @@
+import { getApiClient } from './client.js';
+const typeMap = {
+    track: 1,
+    album: 10,
+    playlist: 1000,
+    artist: 100,
+};
+function transformTrack(track) {
+    return {
+        id: String(track.id),
+        name: track.name,
+        artists: track.ar.map((a) => ({ id: String(a.id), name: a.name })),
+        album: {
+            id: String(track.al.id),
+            name: track.al.name,
+            picUrl: track.al.picUrl,
+        },
+        duration: track.dt,
+        uri: `netease:track:${track.id}`,
+    };
+}
+function transformAlbum(album) {
+    return {
+        id: String(album.id),
+        name: album.name,
+        picUrl: album.picUrl,
+    };
+}
+function transformPlaylist(playlist) {
+    return {
+        id: String(playlist.id),
+        name: playlist.name,
+        description: playlist.description,
+        coverUrl: playlist.coverImgUrl,
+        trackCount: playlist.trackCount,
+        creator: playlist.creator
+            ? {
+                id: String(playlist.creator.userId),
+                name: playlist.creator.nickname,
+            }
+            : undefined,
+    };
+}
+function transformArtist(artist) {
+    return {
+        id: String(artist.id),
+        name: artist.name,
+    };
+}
+export async function search(keyword, type = 'track', limit = 20, offset = 0) {
+    const client = getApiClient();
+    const response = await client.request('/cloudsearch/get/web', {
+        s: keyword,
+        type: typeMap[type],
+        limit,
+        offset,
+    });
+    const result = {
+        total: 0,
+        offset,
+        limit,
+    };
+    switch (type) {
+        case 'track':
+            result.tracks = (response.result.songs || []).map(transformTrack);
+            result.total = response.result.songCount || 0;
+            break;
+        case 'album':
+            result.albums = (response.result.albums || []).map(transformAlbum);
+            result.total = response.result.albumCount || 0;
+            break;
+        case 'playlist':
+            result.playlists = (response.result.playlists || []).map(transformPlaylist);
+            result.total = response.result.playlistCount || 0;
+            break;
+        case 'artist':
+            result.artists = (response.result.artists || []).map(transformArtist);
+            result.total = response.result.artistCount || 0;
+            break;
+    }
+    return result;
+}

package/dist/api/track.d.ts

@@ -0,0 +1,9 @@
+import type { Track, Lyric, Quality } from '../types/index.js';
+export declare function getTrackDetail(id: string): Promise<Track>;
+export declare function getTrackUrl(id: string, quality?: Quality): Promise<string>;
+export declare function getLyric(id: string): Promise<Lyric>;
+export declare function downloadTrack(id: string, quality?: Quality, outputPath?: string): Promise<{
+    path: string;
+    size: number;
+}>;
+export declare function getTrackDetails(ids: string[]): Promise<Track[]>;