gerdur 0.0.0-probe → 1.0.0

package/dist/src/lib/decrypt-pool.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptDownloadFile = void 0;
+const os_1 = require("os");
+const path_1 = require("path");
+const worker_threads_1 = require("worker_threads");
+const idleTimeoutMs = 5000;
+const maxWorkers = Math.max(1, Math.min(4, (0, os_1.cpus)().length));
+const workers = new Set();
+const queue = [];
+let nextJobId = 0;
+const getWorkerOptions = () => {
+    if (__filename.endsWith('.ts')) {
+        return {
+            path: (0, path_1.join)(__dirname, 'decrypt-worker.ts'),
+            execArgv: ['-r', 'ts-node/register'],
+        };
+    }
+    return {
+        path: (0, path_1.join)(__dirname, 'decrypt-worker.js'),
+        execArgv: process.execArgv,
+    };
+};
+const toBuffer = (outFile) => {
+    if (Buffer.isBuffer(outFile)) {
+        return outFile;
+    }
+    return Buffer.from(outFile.buffer, outFile.byteOffset, outFile.byteLength);
+};
+const disposeWorker = (state) => {
+    if (state.idleTimer) {
+        clearTimeout(state.idleTimer);
+    }
+    workers.delete(state);
+    void state.worker.terminate();
+};
+const rejectCurrent = (state, err) => {
+    if (state.current) {
+        state.current.reject(err);
+        state.current = undefined;
+    }
+};
+const scheduleIdleShutdown = (state) => {
+    if (state.idleTimer) {
+        clearTimeout(state.idleTimer);
+    }
+    state.idleTimer = setTimeout(() => disposeWorker(state), idleTimeoutMs);
+};
+const createWorker = () => {
+    const { path, execArgv } = getWorkerOptions();
+    const state = { worker: new worker_threads_1.Worker(path, { execArgv }) };
+    state.worker.on('message', ({ outFile, error, stack }) => {
+        const job = state.current;
+        state.current = undefined;
+        if (!job) {
+            return;
+        }
+        if (error) {
+            const err = new Error(error);
+            err.stack = stack;
+            job.reject(err);
+        }
+        else if (outFile) {
+            job.resolve(toBuffer(outFile));
+        }
+        else {
+            job.reject(new Error('Decrypt worker returned no output'));
+        }
+        runNextJob();
+    });
+    state.worker.on('error', (err) => {
+        rejectCurrent(state, err);
+        workers.delete(state);
+        runNextJob();
+    });
+    state.worker.on('exit', (code) => {
+        workers.delete(state);
+        if (code !== 0) {
+            rejectCurrent(state, new Error(`Decrypt worker exited with code ${code}`));
+            runNextJob();
+        }
+    });
+    workers.add(state);
+    return state;
+};
+const getAvailableWorker = () => {
+    for (const state of workers) {
+        if (!state.current) {
+            return state;
+        }
+    }
+    if (workers.size < maxWorkers) {
+        return createWorker();
+    }
+};
+function runNextJob() {
+    const job = queue.shift();
+    if (!job) {
+        for (const state of workers) {
+            if (!state.current) {
+                scheduleIdleShutdown(state);
+            }
+        }
+        return;
+    }
+    const state = getAvailableWorker();
+    if (!state) {
+        queue.unshift(job);
+        return;
+    }
+    if (state.idleTimer) {
+        clearTimeout(state.idleTimer);
+        state.idleTimer = undefined;
+    }
+    state.current = job;
+    state.worker.postMessage({ id: job.id, tmpfile: job.tmpfile, trackId: job.trackId });
+}
+const decryptDownloadFile = (tmpfile, trackId) => new Promise((resolve, reject) => {
+    queue.push({ id: nextJobId++, tmpfile, trackId, resolve, reject });
+    runNextJob();
+});
+exports.decryptDownloadFile = decryptDownloadFile;

package/dist/src/lib/decrypt-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/decrypt-worker.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const decrypt_1 = require("./decrypt");
+if (!worker_threads_1.parentPort) {
+    throw new Error('decrypt-worker must run inside a worker thread');
+}
+worker_threads_1.parentPort.on('message', ({ id, tmpfile, trackId }) => {
+    try {
+        const outFile = (0, decrypt_1.decryptDownloadFile)(tmpfile, trackId);
+        worker_threads_1.parentPort?.postMessage({ id, outFile }, [outFile.buffer]);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        worker_threads_1.parentPort?.postMessage({ id, error: error.message, stack: error.stack });
+    }
+});

package/dist/src/lib/decrypt.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const decryptDownload: (source: Buffer, trackId: string) => Buffer;
+export declare const decryptDownloadFile: (tmpfile: string, trackId: string) => Buffer;

package/dist/src/lib/decrypt.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptDownloadFile = exports.decryptDownload = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = require("fs");
+const gerdur_core_1 = require("gerdur-core");
+const egoroof_blowfish_1 = require("egoroof-blowfish");
+const md5 = (data, type = 'ascii') => {
+    const md5sum = crypto_1.default.createHash('md5');
+    md5sum.update(data.toString(), type);
+    return md5sum.digest('hex');
+};
+const getBlowfishKey = (trackId) => {
+    const SECRET = 'g4el58wc0zvf9na1';
+    const idMd5 = md5(trackId);
+    let bfKey = '';
+    for (let i = 0; i < 16; i++) {
+        bfKey += String.fromCharCode(idMd5.charCodeAt(i) ^ idMd5.charCodeAt(i + 16) ^ SECRET.charCodeAt(i));
+    }
+    return bfKey;
+};
+const decryptChunkFallback = (chunk, blowFishKey) => {
+    const bf = new egoroof_blowfish_1.Blowfish(blowFishKey, egoroof_blowfish_1.Blowfish.MODE.CBC, egoroof_blowfish_1.Blowfish.PADDING.NULL);
+    bf.setIv(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]));
+    return Buffer.from(bf.decode(new Uint8Array(chunk)));
+};
+const decryptChunkNative = (chunk, blowFishKey) => {
+    const cipher = crypto_1.default.createDecipheriv('bf-cbc', blowFishKey, Buffer.from([0, 1, 2, 3, 4, 5, 6, 7]));
+    cipher.setAutoPadding(false);
+    return Buffer.concat([cipher.update(chunk), cipher.final()]);
+};
+const decryptChunk = (chunk, blowFishKey) => {
+    try {
+        return decryptChunkNative(chunk, blowFishKey);
+    }
+    catch (err) {
+        if (!canFallback(err)) {
+            throw err;
+        }
+        return decryptChunkFallback(chunk, blowFishKey);
+    }
+};
+const decryptDownloadFallback = (source, trackId) => {
+    const chunkSize = 2048;
+    const blowFishKey = getBlowfishKey(trackId);
+    const destBuffer = Buffer.alloc(source.length);
+    let chunkIndex = 0;
+    let position = 0;
+    while (position < source.length) {
+        const currentChunkSize = Math.min(chunkSize, source.length - position);
+        const sourceChunk = source.subarray(position, position + currentChunkSize);
+        if (chunkIndex % 3 > 0 || currentChunkSize < chunkSize) {
+            sourceChunk.copy(destBuffer, position);
+        }
+        else {
+            decryptChunk(sourceChunk, blowFishKey).copy(destBuffer, position);
+        }
+        position += currentChunkSize;
+        chunkIndex++;
+    }
+    return destBuffer;
+};
+const canFallback = (err) => {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const code = err.code;
+    return code === 'ERR_OSSL_EVP_UNSUPPORTED' || err.message.includes('digital envelope routines::unsupported');
+};
+const decryptDownload = (source, trackId) => {
+    try {
+        return (0, gerdur_core_1.decryptDownload)(source, trackId);
+    }
+    catch (err) {
+        if (!canFallback(err)) {
+            throw err;
+        }
+        return decryptDownloadFallback(source, trackId);
+    }
+};
+exports.decryptDownload = decryptDownload;
+const decryptDownloadFile = (tmpfile, trackId) => {
+    const chunkSize = 2048;
+    const blowFishKey = getBlowfishKey(trackId);
+    const sourceLength = (0, fs_1.statSync)(tmpfile).size;
+    const destBuffer = Buffer.alloc(sourceLength);
+    const chunk = Buffer.alloc(chunkSize);
+    const fd = (0, fs_1.openSync)(tmpfile, 'r');
+    let chunkIndex = 0;
+    let position = 0;
+    try {
+        while (position < sourceLength) {
+            const currentChunkSize = Math.min(chunkSize, sourceLength - position);
+            const bytesRead = (0, fs_1.readSync)(fd, chunk, 0, currentChunkSize, position);
+            const sourceChunk = chunk.subarray(0, bytesRead);
+            if (chunkIndex % 3 > 0 || bytesRead < chunkSize) {
+                sourceChunk.copy(destBuffer, position);
+            }
+            else {
+                decryptChunk(sourceChunk, blowFishKey).copy(destBuffer, position);
+            }
+            position += bytesRead;
+            chunkIndex++;
+        }
+    }
+    finally {
+        (0, fs_1.closeSync)(fd);
+    }
+    return destBuffer;
+};
+exports.decryptDownloadFile = decryptDownloadFile;

package/dist/src/lib/download-track.d.ts

@@ -0,0 +1,24 @@
+import type { trackType } from 'gerdur-core/types';
+interface downloadTrackProps {
+    track: trackType;
+    quality: string | number;
+    info: {
+        [key: string]: any;
+    };
+    coverSizes: {
+        '128': number;
+        '320': number;
+        flac: number;
+    };
+    path: string;
+    totalTracks: number;
+    trackNumber?: boolean;
+    fallbackTrack?: boolean;
+    fallbackQuality?: boolean;
+    isFallback?: boolean;
+    isQualityFallback?: boolean;
+    overwrite?: boolean;
+    message?: string;
+}
+declare const downloadTrack: ({ track, quality, info, coverSizes, path, totalTracks, trackNumber, fallbackTrack, fallbackQuality, isFallback, isQualityFallback, overwrite, message, }: downloadTrackProps) => Promise<string | undefined>;
+export default downloadTrack;

package/dist/src/lib/download-track.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const got_1 = __importDefault(require("got"));
+const stream_1 = __importDefault(require("stream"));
+const fs_1 = require("fs");
+const util_1 = require("util");
+const path_1 = require("path");
+const gerdur_core_1 = require("gerdur-core");
+const log_update_1 = __importDefault(require("log-update"));
+const chalk_1 = __importDefault(require("chalk"));
+const signale_1 = __importDefault(require("../lib/signale"));
+const util_2 = require("./util");
+const decrypt_pool_1 = require("./decrypt-pool");
+const pipeline = (0, util_1.promisify)(stream_1.default.pipeline);
+const simulate = process.env.SIMULATE;
+const downloadTrack = async ({ track, quality, info, coverSizes, path, totalTracks, trackNumber = true, fallbackTrack = true, fallbackQuality = true, isFallback = false, isQualityFallback = false, overwrite = false, message = '', }) => {
+    (0, log_update_1.default)(signale_1.default.pending(track.SNG_TITLE + ' by ' + track.ART_NAME + ' from ' + track.ALB_TITLE));
+    try {
+        let ext = '.mp3', fileSize = 0, downloaded = 0, coverSize = 500;
+        switch (quality) {
+            case 1:
+            case '1':
+            case '128':
+            case 'MP3_128':
+            case '128kbps':
+                quality = 1;
+                fileSize = Number(track.FILESIZE_MP3_128);
+                coverSize = coverSizes['128'];
+                break;
+            case 9:
+            case '9':
+            case 'flac':
+            case 'Flac':
+            case 'FLAC':
+                quality = 9;
+                ext = '.flac';
+                fileSize = Number(track.FILESIZE_FLAC);
+                coverSize = coverSizes['flac'];
+                break;
+            default:
+                quality = 3;
+                fileSize = Number(track.FILESIZE_MP3_320);
+                coverSize = coverSizes['320'];
+        }
+        const savePath = (0, util_2.saveLayout)({ track, album: info, path, trackNumber, minimumIntegerDigits: totalTracks >= 100 ? 3 : 2 }) + ext;
+        if ((0, fs_1.existsSync)(savePath) && !overwrite) {
+            (0, log_update_1.default)(signale_1.default.info(`Skipped "${track.SNG_TITLE}", track already exists.`));
+            log_update_1.default.done();
+            (0, log_update_1.default)(signale_1.default.note(savePath));
+            log_update_1.default.done();
+            return savePath;
+        }
+        let trackData;
+        try {
+            trackData = await (0, gerdur_core_1.getTrackDownloadUrl)(track, quality);
+        }
+        catch (err) {
+            if (!(err instanceof gerdur_core_1.GeoBlocked) || !track.FALLBACK) {
+                throw err;
+            }
+        }
+        if (!trackData) {
+            if (fallbackTrack && track.FALLBACK && !isFallback && track.ART_ID === track.FALLBACK.ART_ID) {
+                const { FALLBACK, ...CURRENT_TRACK } = track;
+                return await downloadTrack({
+                    track: { ...CURRENT_TRACK, ...FALLBACK },
+                    quality,
+                    info,
+                    coverSizes,
+                    path,
+                    totalTracks,
+                    trackNumber,
+                    fallbackTrack: false,
+                    isFallback: true,
+                    overwrite,
+                    message,
+                });
+            }
+            else if (fallbackQuality && quality !== 1) {
+                return await downloadTrack({
+                    track,
+                    quality: quality === 9 ? 3 : 1,
+                    info,
+                    coverSizes,
+                    path,
+                    totalTracks,
+                    trackNumber,
+                    fallbackTrack,
+                    isFallback,
+                    isQualityFallback: true,
+                    overwrite,
+                    message,
+                });
+            }
+            (0, log_update_1.default)(signale_1.default.warn(`Skipped "${track.SNG_TITLE}", track not available.`));
+            log_update_1.default.done();
+            return;
+        }
+        const headers = {};
+        const tmpfile = `gerdur_${quality}_${track.SNG_ID}_${simulate ? 'simulate' : track.MD5_ORIGIN}`;
+        if (simulate) {
+            coverSize = 56;
+            headers.range = 'bytes=0-1023';
+        }
+        else if ((0, fs_1.existsSync)(tmpfile)) {
+            const tmpfilestat = (0, fs_1.statSync)(tmpfile);
+            downloaded = tmpfilestat.size;
+            headers.range = 'bytes=' + tmpfilestat.size + '-';
+        }
+        fileSize = trackData.fileSize;
+        const bar = (0, util_2.progressBar)(fileSize, 40);
+        const humanSizeTotal = (fileSize / 1024 / 1024).toFixed(2);
+        let transferredLast = downloaded;
+        await pipeline(got_1.default.stream(trackData.trackUrl, { responseType: 'buffer', headers }).on('downloadProgress', ({ transferred }) => {
+            // Report download progress
+            transferred += downloaded;
+            if (transferred - transferredLast > 50000) {
+                transferredLast = transferred;
+                (0, log_update_1.default)(signale_1.default.info(`Downloading ${track.SNG_TITLE} ${message}\n  ${bar(transferred)} | ${humanSizeTotal}MiB`));
+            }
+        }), (0, fs_1.createWriteStream)(tmpfile, { flags: 'a', autoClose: true }));
+        let outFile;
+        if (trackData.isEncrypted) {
+            (0, log_update_1.default)(signale_1.default.pending('Decrypting ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+            outFile = await (0, decrypt_pool_1.decryptDownloadFile)(tmpfile, track.SNG_ID);
+        }
+        else {
+            outFile = (0, fs_1.readFileSync)(tmpfile);
+        }
+        (0, log_update_1.default)(signale_1.default.pending('Tagging ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+        const trackWithMetadata = await (0, gerdur_core_1.addTrackTags)(outFile, track, coverSize);
+        // Delete temporary file now
+        (0, fs_1.unlinkSync)(tmpfile);
+        (0, log_update_1.default)(signale_1.default.pending('Saving ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+        if (!simulate) {
+            // Create directory if not exists
+            const dir = (0, path_1.dirname)(savePath);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            // Save file to disk
+            (0, fs_1.writeFileSync)(savePath, trackWithMetadata);
+        }
+        // Print sucess info
+        (0, log_update_1.default)(signale_1.default.success(`${isFallback ? chalk_1.default.yellow('[Fallback] ') : ''}${track.SNG_TITLE} by ${track.ART_NAME}`));
+        log_update_1.default.done();
+        if (isQualityFallback) {
+            (0, log_update_1.default)(signale_1.default.note(`Used ${quality === 3 ? '320kbps' : '128kbps'} as other formats were unavailable`));
+            log_update_1.default.done();
+        }
+        return savePath;
+    }
+    catch (err) {
+        (0, log_update_1.default)(signale_1.default.error(track.SNG_TITLE));
+        log_update_1.default.done();
+        (0, log_update_1.default)(signale_1.default.note(err.message));
+        log_update_1.default.done();
+    }
+};
+exports.default = downloadTrack;

package/dist/src/lib/email-login.d.ts

@@ -0,0 +1,16 @@
+/** Discriminated result so the caller can branch on the failure reason. */
+export type LoginResult = {
+    ok: true;
+    arl: string;
+} | {
+    ok: false;
+    reason: 'wrong-credentials' | 'no-arl' | 'network' | 'unknown';
+    message: string;
+};
+/**
+ * Attempt to obtain an arl for the given credentials.
+ *
+ * The password is MD5-hashed and folded into the app hash before transmission;
+ * it is never written anywhere by this function.
+ */
+export declare const loginWithEmail: (email: string, password: string) => Promise<LoginResult>;

package/dist/src/lib/email-login.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginWithEmail = void 0;
+const crypto_1 = require("crypto");
+const got_1 = __importDefault(require("got"));
+/**
+ * Email/password -> arl login for Deezer.
+ *
+ * Uses Deezer's mobile OAuth endpoint (connect.deezer.com/oauth/user_auth.php)
+ * rather than the web login form, which is bot-protected. The approach and the
+ * public app credentials/hash scheme mirror the well-known deemix flow.
+ *
+ * This is still best-effort: Deezer may reject the login (bad credentials,
+ * account protections, or changes on their side), in which case the caller
+ * should fall back to pasting an arl. Passwords handled here are never persisted
+ * or logged; only the resulting arl is returned.
+ */
+// Public Deezer app credentials used by the mobile OAuth flow (same values used
+// by deemix and similar tools). Not secret in any meaningful sense.
+const CLIENT_ID = '447462';
+const CLIENT_SECRET = 'a83bf7f38ad2f137e444727cfc3775cf';
+const UA = 'Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0';
+const md5 = (data) => (0, crypto_1.createHash)('md5').update(Buffer.from(data, 'utf8')).digest('hex');
+/**
+ * Merge `set-cookie` response headers into a cookie map (last value wins),
+ * emulating a cookie jar shared across the login requests.
+ */
+const collectCookies = (jar, setCookie) => {
+    if (!setCookie) {
+        return;
+    }
+    for (const raw of setCookie) {
+        const [pair] = raw.split(';');
+        const eq = pair.indexOf('=');
+        if (eq > 0) {
+            const name = pair.slice(0, eq).trim();
+            const value = pair.slice(eq + 1).trim();
+            if (name) {
+                jar.set(name, value);
+            }
+        }
+    }
+};
+const cookieHeader = (jar) => [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ');
+/**
+ * Attempt to obtain an arl for the given credentials.
+ *
+ * The password is MD5-hashed and folded into the app hash before transmission;
+ * it is never written anywhere by this function.
+ */
+const loginWithEmail = async (email, password) => {
+    const jar = new Map();
+    try {
+        // 1. Bootstrap a session so Deezer sets an initial sid cookie.
+        const boot = await (0, got_1.default)('https://www.deezer.com', {
+            method: 'POST',
+            headers: { 'User-Agent': UA },
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, boot.headers['set-cookie']);
+        // 2. Authenticate via the mobile OAuth endpoint. The password is hashed,
+        //    then combined with the public app id/secret into the request hash.
+        const passwordHash = md5(password);
+        const hash = md5([CLIENT_ID, email, passwordHash, CLIENT_SECRET].join(''));
+        let accessToken = null;
+        const auth = await (0, got_1.default)('https://connect.deezer.com/oauth/user_auth.php', {
+            searchParams: { app_id: CLIENT_ID, login: email, password: passwordHash, hash },
+            headers: { 'User-Agent': UA, cookie: cookieHeader(jar) },
+            responseType: 'json',
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, auth.headers['set-cookie']);
+        const authBody = auth.body ?? {};
+        if (authBody.access_token && authBody.access_token !== 'undefined') {
+            accessToken = authBody.access_token;
+        }
+        if (!accessToken && !jar.has('arl') && (authBody.error || auth.statusCode >= 400)) {
+            return { ok: false, reason: 'wrong-credentials', message: 'Login failed — check your email and password.' };
+        }
+        // 3. Read the arl for the now-authenticated session.
+        const arlResp = await (0, got_1.default)('https://www.deezer.com/ajax/gw-light.php', {
+            searchParams: { method: 'user.getArl', input: 3, api_version: '1.0', api_token: 'null' },
+            headers: { 'User-Agent': UA, cookie: cookieHeader(jar) },
+            responseType: 'json',
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, arlResp.headers['set-cookie']);
+        const arl = arlResp.body?.results;
+        if (typeof arl === 'string' && arl.length === 192) {
+            return { ok: true, arl };
+        }
+        if (jar.has('arl') && jar.get('arl').length === 192) {
+            return { ok: true, arl: jar.get('arl') };
+        }
+        return {
+            ok: false,
+            reason: 'no-arl',
+            message: 'Logged in but could not retrieve an arl. Please paste your arl instead.',
+        };
+    }
+    catch (err) {
+        return { ok: false, reason: 'network', message: err?.message || 'Network error during login.' };
+    }
+};
+exports.loginWithEmail = loginWithEmail;

package/dist/src/lib/session.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { parseInfo, searchMusic } from 'gerdur-core';
+import type { Quality, DownloadTrackOptions, DownloadResult } from './api-download';
+import type { trackType, userType } from 'gerdur-core/types';
+/** Search result categories accepted by {@link Session.search}. */
+export type SearchType = 'ALBUM' | 'ARTIST' | 'TRACK' | 'PLAYLIST' | 'RADIO' | 'SHOW' | 'USER' | 'LIVESTREAM' | 'CHANNEL';
+export interface SessionOptions {
+    /** Deezer arl cookie. Provide this OR email+password. */
+    arl?: string;
+    /** Deezer account email (used with `password` to fetch an arl). */
+    email?: string;
+    /** Deezer account password. */
+    password?: string;
+    /** Default download concurrency for `downloadTracks`. Default 4. */
+    concurrency?: number;
+}
+export interface DownloadTracksOptions extends DownloadTrackOptions {
+    /** Concurrent downloads. Defaults to the session concurrency. */
+    concurrency?: number;
+    /**
+     * Called after each track settles, with the running progress. `result` is the
+     * download result (or `null` if the track was unavailable / errored).
+     */
+    onProgress?: (progress: {
+        index: number;
+        total: number;
+        track: trackType;
+        result: DownloadResult | null;
+    }) => void;
+}
+/**
+ * An authenticated Deezer session exposing high-level query and download
+ * helpers. Create one with {@link createSession}. All methods are silent (no
+ * console output); use `onProgress` callbacks for progress.
+ */
+export declare class Session {
+    /** The arl in use for this session. */
+    readonly arl: string;
+    private concurrency;
+    private constructor();
+    /**
+     * Log in and return a ready-to-use session. Accepts either an `arl` or
+     * `email`+`password` (which are exchanged for an arl via Deezer's OAuth flow).
+     */
+    static create(options: SessionOptions): Promise<Session>;
+    /** Fetch the logged-in user profile. */
+    getUser(): Promise<userType>;
+    /**
+     * Resolve any supported URL (Deezer/Spotify/Tidal track, album, playlist, or
+     * artist) into its info + track list.
+     */
+    parseUrl(url: string): ReturnType<typeof parseInfo>;
+    /** Search Deezer. Defaults to track results. */
+    search(query: string, types?: SearchType[], limit?: number): ReturnType<typeof searchMusic>;
+    /** Return a fully tagged audio Buffer for a track (nothing written to disk). */
+    getTrackBuffer(track: trackType, quality?: Quality, options?: {}): Promise<Buffer | null>;
+    /** Download a single track to disk. */
+    downloadTrack(track: trackType, quality?: Quality, options?: DownloadTrackOptions): Promise<DownloadResult | null>;
+    /**
+     * Download many tracks with bounded concurrency. Resolves to one result per
+     * input track (in the original order); entries are `null` for tracks that
+     * were unavailable or errored. Progress is reported via `onProgress`.
+     */
+    downloadTracks(tracks: trackType[], quality?: Quality, options?: DownloadTracksOptions): Promise<(DownloadResult | null)[]>;
+    /**
+     * Convenience: resolve a URL and download all of its tracks in one call.
+     * Uses the linked album/playlist info for filename templating.
+     */
+    downloadUrl(url: string, quality?: Quality, options?: DownloadTracksOptions): Promise<(DownloadResult | null)[]>;
+}
+/**
+ * Create and log in an authenticated {@link Session}.
+ *
+ * @example
+ * ```ts
+ * const session = await createSession({arl: '...'});          // or {email, password}
+ * const {tracks, linkinfo} = await session.parseUrl(url);
+ * await session.downloadTracks(tracks, 'flac', {
+ *   output: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+ *   onProgress: ({index, total}) => console.log(`${index + 1}/${total}`),
+ * });
+ * ```
+ */
+export declare const createSession: (options: SessionOptions) => Promise<Session>;