@bililive-tools/manager 1.8.0 → 1.10.0

package/README.md

@@ -94,19 +94,22 @@ setBililivePath("BililiveRecorder.Cli.exe");
 
 默认值为 `{platform}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}`
 
-| 值          | 标签   |
-| ----------- | ------ |
-| {platform}  | 平台   |
-| {channelId} | 房间号 |
-| {remarks}   | 备注   |
-| {owner}     | 主播名 |
-| {title}     | 标题   |
-| {year}      | 年     |
-| {month}     | 月     |
-| {date}      | 日     |
-| {hour}      | 时     |
-| {min}       | 分     |
-| {sec}       | 秒     |
+| 值                | 标签                                       |
+| ----------------- | ------------------------------------------ |
+| {platform}        | 平台                                       |
+| {channelId}       | 房间号                                     |
+| {remarks}         | 备注                                       |
+| {owner}           | 主播名                                     |
+| {title}           | 标题                                       |
+| {year}            | 年                                         |
+| {month}           | 月                                         |
+| {date}            | 日                                         |
+| {hour}            | 时                                         |
+| {min}             | 分                                         |
+| {sec}             | 秒                                         |
+| {startTime}       | 分段开始时间，Date对象                     |
+| {recordStartTime} | 录制开始时间，Date对象                     |
+| {liveStartTime}   | 直播开始时间，Date对象，抖音同录制开始时间 |
 
 ## 事件
 

package/lib/cache.d.ts

@@ -1,17 +1,56 @@
-export declare class Cache {
-    private static instance;
-    private data;
-    private constructor();
-    static getInstance(): Cache;
-    set(key: string, value: any): void;
-    get(key: string): any;
-    has(key: string): boolean;
-    delete(key: string): boolean;
-    clear(): void;
-    get size(): number;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<any>;
-    entries(): IterableIterator<[string, any]>;
-    forEach(callbackfn: (value: any, key: string, map: Map<string, any>) => void, thisArg?: any): void;
-    [Symbol.iterator](): IterableIterator<[string, any]>;
+/**
+ * Cache system for RecorderManager
+ * 提供统一的缓存接口用于处理持久化事务
+ */
+export interface CacheStore {
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+export interface RecorderCache {
+    /**
+     * 为每个录制器创建独立的命名空间
+     * @param recorderId 录制器 ID
+     */
+    createNamespace(recorderId: string): NamespacedCache;
+    /**
+     * 获取全局缓存
+     */
+    global(): NamespacedCache;
+}
+export interface NamespacedCache {
+    /**
+     * 通用的 key-value 存储
+     */
+    get<T = any>(key: string): Promise<T | undefined>;
+    /**
+     * 通用的 key-value 存储
+     */
+    set<T = any>(key: string, value: T): Promise<void>;
+    /**
+     * 删除指定 key
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * 内存缓存实现
+ */
+export declare class MemoryCacheStore implements CacheStore {
+    private store;
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+/**
+ * RecorderCache 实现
+ */
+export declare class RecorderCacheImpl implements RecorderCache {
+    private store;
+    constructor(store: CacheStore);
+    createNamespace(recorderId: string): NamespacedCache;
+    global(): NamespacedCache;
 }

package/lib/cache.js

@@ -1,47 +1,75 @@
-export class Cache {
-    static instance;
-    data;
-    constructor() {
-        this.data = new Map();
-    }
-    static getInstance() {
-        if (!Cache.instance) {
-            Cache.instance = new Cache();
+/**
+ * Cache system for RecorderManager
+ * 提供统一的缓存接口用于处理持久化事务
+ */
+/**
+ * 内存缓存实现
+ */
+export class MemoryCacheStore {
+    store = new Map();
+    async get(key) {
+        const item = this.store.get(key);
+        if (!item)
+            return undefined;
+        if (item.expireAt && Date.now() > item.expireAt) {
+            this.store.delete(key);
+            return undefined;
         }
-        return Cache.instance;
+        return item.value;
     }
-    set(key, value) {
-        this.data.set(key, value);
+    async set(key, value, ttl) {
+        const item = { value };
+        if (ttl) {
+            item.expireAt = Date.now() + ttl;
+        }
+        this.store.set(key, item);
+    }
+    async delete(key) {
+        this.store.delete(key);
     }
-    get(key) {
-        return this.data.get(key);
+    async clear() {
+        this.store.clear();
     }
-    has(key) {
-        return this.data.has(key);
+    async has(key) {
+        const value = await this.get(key);
+        return value !== undefined;
     }
-    delete(key) {
-        return this.data.delete(key);
+}
+/**
+ * RecorderCache 实现
+ */
+export class RecorderCacheImpl {
+    store;
+    constructor(store) {
+        this.store = store;
     }
-    clear() {
-        this.data.clear();
+    createNamespace(recorderId) {
+        return new NamespacedCacheImpl(this.store, `recorder:${recorderId}`);
     }
-    get size() {
-        return this.data.size;
+    global() {
+        return new NamespacedCacheImpl(this.store, "global");
     }
-    keys() {
-        return this.data.keys();
+}
+/**
+ * 命名空间缓存实现
+ */
+class NamespacedCacheImpl {
+    store;
+    namespace;
+    constructor(store, namespace) {
+        this.store = store;
+        this.namespace = namespace;
     }
-    values() {
-        return this.data.values();
+    getKey(key) {
+        return `${this.namespace}:${key}`;
     }
-    entries() {
-        return this.data.entries();
+    async get(key) {
+        return this.store.get(this.getKey(key));
     }
-    forEach(callbackfn, thisArg) {
-        this.data.forEach(callbackfn, thisArg);
+    async set(key, value) {
+        return this.store.set(this.getKey(key), value);
     }
-    // 实现 Symbol.iterator 接口，支持 for...of 循环
-    [Symbol.iterator]() {
-        return this.data[Symbol.iterator]();
+    async delete(key) {
+        return this.store.delete(this.getKey(key));
     }
 }

package/lib/common.d.ts

@@ -1,11 +1,10 @@
 import { AnyObject, UnknownObject } from "./utils.js";
 export type ChannelId = string;
 export declare const Qualities: readonly ["lowest", "low", "medium", "high", "highest"];
-export declare const BiliQualities: readonly [30000, 20000, 10000, 400, 250, 150, 80];
 export declare const DouyuQualities: readonly [0, 2, 3, 4, 8];
 export declare const HuYaQualities: readonly [0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500, -1];
 export declare const DouYinQualities: readonly ["origin", "uhd", "hd", "sd", "ld", "ao", "real_origin"];
-export type Quality = (typeof Qualities)[number] | (typeof BiliQualities)[number] | (typeof DouyuQualities)[number] | (typeof HuYaQualities)[number] | (typeof DouYinQualities)[number];
+export type Quality = string | number;
 export interface MessageSender<E extends AnyObject = UnknownObject> {
     uid?: string;
     name: string;

package/lib/common.js

@@ -1,5 +1,4 @@
 export const Qualities = ["lowest", "low", "medium", "high", "highest"];
-export const BiliQualities = [30000, 20000, 10000, 400, 250, 150, 80];
 export const DouyuQualities = [0, 2, 3, 4, 8];
 // 14100: 2K HDR；14000：2K；4200：HDR(10M)；0：原画；8000：蓝光8M；4000：蓝光4M；2000：超清；500：流畅
 export const HuYaQualities = [

package/lib/{recorder/BililiveRecorder.d.ts → downloader/BililiveDownloader.d.ts}

@@ -1,5 +1,5 @@
 import EventEmitter from "node:events";
-import { IRecorder, BililiveRecorderOptions } from "./IRecorder.js";
+import { IDownloader, BililiveRecorderOptions, Segment } from "./IDownloader.js";
 declare class BililiveRecorderCommand extends EventEmitter {
     private _input;
     private _output;
@@ -15,7 +15,7 @@ declare class BililiveRecorderCommand extends EventEmitter {
     kill(signal?: NodeJS.Signals): void;
 }
 export declare const createBililiveBuilder: () => BililiveRecorderCommand;
-export declare class BililiveRecorder extends EventEmitter implements IRecorder {
+export declare class BililiveDownloader extends EventEmitter implements IDownloader {
     private onEnd;
     private onUpdateLiveInfo;
     type: "bililive";
@@ -26,9 +26,8 @@ export declare class BililiveRecorder extends EventEmitter implements IRecorder
         startTime: number;
         title?: string;
     }) => string;
-    readonly segment: number;
+    readonly segment: Segment;
     readonly inputOptions: string[];
-    readonly disableDanma: boolean;
     readonly url: string;
     readonly debugLevel: "none" | "basic" | "verbose";
     readonly headers: {
@@ -46,5 +45,6 @@ export declare class BililiveRecorder extends EventEmitter implements IRecorder
     getArguments(): string[];
     stop(): Promise<void>;
     getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+    get videoFilePath(): string;
 }
 export {};

package/lib/{recorder/BililiveRecorder.js → downloader/BililiveDownloader.js}

@@ -1,6 +1,7 @@
 import EventEmitter from "node:events";
 import { spawn } from "node:child_process";
 import { StreamManager, getBililivePath } from "../index.js";
+import { byte2MB } from "../utils.js";
 // Bililive command builder class similar to ffmpeg
 class BililiveRecorderCommand extends EventEmitter {
     _input = "";
@@ -43,7 +44,6 @@ class BililiveRecorderCommand extends EventEmitter {
     run() {
         const args = this._getArguments();
         const bililiveExecutable = getBililivePath();
-        console.log("Starting BililiveRecorder with args:", bililiveExecutable, args);
         this.process = spawn(bililiveExecutable, args, {
             stdio: ["pipe", "pipe", "pipe"],
         });
@@ -84,7 +84,7 @@ class BililiveRecorderCommand extends EventEmitter {
 export const createBililiveBuilder = () => {
     return new BililiveRecorderCommand();
 };
-export class BililiveRecorder extends EventEmitter {
+export class BililiveDownloader extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
     type = "bililive";
@@ -94,7 +94,6 @@ export class BililiveRecorder extends EventEmitter {
     getSavePath;
     segment;
     inputOptions = [];
-    disableDanma = false;
     url;
     debugLevel = "none";
     headers;
@@ -102,22 +101,22 @@ export class BililiveRecorder extends EventEmitter {
         super();
         this.onEnd = onEnd;
         this.onUpdateLiveInfo = onUpdateLiveInfo;
+        // 存在自动分段，永远为true
         const hasSegment = true;
-        this.disableDanma = opts.disableDanma ?? false;
+        this.hasSegment = hasSegment;
         this.debugLevel = opts.debugLevel ?? "none";
         let videoFormat = "flv";
-        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "bililive", videoFormat, {
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, "bililive", videoFormat, {
             onUpdateLiveInfo: this.onUpdateLiveInfo,
         });
-        this.hasSegment = hasSegment;
         this.getSavePath = opts.getSavePath;
         this.inputOptions = [];
         this.url = opts.url;
         this.segment = opts.segment;
         this.headers = opts.headers;
         this.command = this.createCommand();
-        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
-            this.emit("videoFileCreated", { filename, cover, rawFilename });
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename, title }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename, title });
         });
         this.streamManager.on("videoFileCompleted", ({ filename }) => {
             this.emit("videoFileCompleted", { filename });
@@ -142,8 +141,13 @@ export class BililiveRecorder extends EventEmitter {
                 inputOptions.push("-h", `${key}: ${value}`);
             });
         }
-        if (this.hasSegment) {
-            inputOptions.push("-d", `${this.segment}`);
+        if (this.segment) {
+            if (typeof this.segment === "number") {
+                inputOptions.push("-d", `${this.segment}`);
+            }
+            else if (typeof this.segment === "string") {
+                inputOptions.push("-m", byte2MB(Number(this.segment)).toFixed(2));
+            }
         }
         const command = createBililiveBuilder()
             .input(this.url)
@@ -193,4 +197,7 @@ export class BililiveRecorder extends EventEmitter {
     getExtraDataController() {
         return this.streamManager?.getExtraDataController();
     }
+    get videoFilePath() {
+        return this.streamManager.videoFilePath;
+    }
 }

package/lib/{recorder/FFMPEGRecorder.d.ts → downloader/FFmpegDownloader.d.ts}

@@ -1,7 +1,8 @@
 import EventEmitter from "node:events";
-import { IRecorder, FFMPEGRecorderOptions } from "./IRecorder.js";
-import type { FormatName } from "./index.js";
-export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
+import { IDownloader, FFMPEGRecorderOptions, Segment } from "./IDownloader.js";
+import { FormatName } from "./index.js";
+import type { VideoFormat } from "../index.js";
+export declare class FFmpegDownloader extends EventEmitter implements IDownloader {
     private onEnd;
     private onUpdateLiveInfo;
     type: "ffmpeg";
@@ -13,14 +14,13 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
         startTime: number;
         title?: string;
     }) => string;
-    readonly segment: number;
+    readonly segment: Segment;
     ffmpegOutputOptions: string[];
     readonly inputOptions: string[];
     readonly isHls: boolean;
-    readonly disableDanma: boolean;
     readonly url: string;
     formatName: FormatName;
-    videoFormat: "ts" | "mkv" | "mp4";
+    videoFormat: VideoFormat;
     readonly debugLevel: "none" | "basic" | "verbose";
     readonly headers: {
         [key: string]: string | undefined;
@@ -30,6 +30,7 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
         cover?: string;
     }>);
     createCommand(): import("@renmu/fluent-ffmpeg").FfmpegCommand;
+    buildOutputOptions(): string[];
     formatLine(line: string): {
         time: string | null;
     } | null;
@@ -37,4 +38,5 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
     getArguments(): string[];
     stop(): Promise<void>;
     getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+    get videoFilePath(): string;
 }

package/lib/{recorder/FFMPEGRecorder.js → downloader/FFmpegDownloader.js}

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { createFFMPEGBuilder, StreamManager, utils } from "../index.js";
 import { createInvalidStreamChecker, assert } from "../utils.js";
-export class FFMPEGRecorder extends EventEmitter {
+export class FFmpegDownloader extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
     type = "ffmpeg";
@@ -14,7 +14,6 @@ export class FFMPEGRecorder extends EventEmitter {
     ffmpegOutputOptions = [];
     inputOptions = [];
     isHls;
-    disableDanma = false;
     url;
     formatName;
     videoFormat;
@@ -24,7 +23,11 @@ export class FFMPEGRecorder extends EventEmitter {
         super();
         this.onEnd = onEnd;
         this.onUpdateLiveInfo = onUpdateLiveInfo;
-        const hasSegment = !!opts.segment;
+        let hasSegment = false;
+        // 只有数字才表示时间分段，只有时间分段才会在ffmpeg走分段逻辑
+        if (opts.segment && typeof opts.segment === "number") {
+            hasSegment = true;
+        }
         this.hasSegment = hasSegment;
         this.debugLevel = opts.debugLevel ?? "none";
         this.formatName = opts.formatName;
@@ -37,7 +40,7 @@ export class FFMPEGRecorder extends EventEmitter {
         let videoFormat = opts.videoFormat ?? "auto";
         if (videoFormat === "auto") {
             if (!this.hasSegment) {
-                videoFormat = "mp4";
+                videoFormat = "m4s";
                 if (this.formatName === "ts") {
                     videoFormat = "ts";
                 }
@@ -47,8 +50,7 @@ export class FFMPEGRecorder extends EventEmitter {
             }
         }
         this.videoFormat = videoFormat;
-        this.disableDanma = opts.disableDanma ?? false;
-        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "ffmpeg", this.videoFormat, {
+        this.streamManager = new StreamManager(opts.getSavePath, this.hasSegment, "ffmpeg", this.videoFormat, {
             onUpdateLiveInfo: this.onUpdateLiveInfo,
         });
         this.timeoutChecker = utils.createTimeoutChecker(() => this.onEnd("ffmpeg timeout"), 3 * 10e3, false);
@@ -59,8 +61,8 @@ export class FFMPEGRecorder extends EventEmitter {
         this.segment = opts.segment;
         this.headers = opts.headers;
         this.command = this.createCommand();
-        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
-            this.emit("videoFileCreated", { filename, cover, rawFilename });
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename, title }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename, title });
         });
         this.streamManager.on("videoFileCompleted", ({ filename }) => {
             this.emit("videoFileCompleted", { filename });
@@ -95,10 +97,11 @@ export class FFMPEGRecorder extends EventEmitter {
                 inputOptions.push("-headers", headers.join("\\r\\n"));
             }
         }
+        const outputOptions = this.buildOutputOptions();
         const command = createFFMPEGBuilder()
             .input(this.url)
             .inputOptions(inputOptions)
-            .outputOptions(this.ffmpegOutputOptions)
+            .outputOptions(outputOptions)
             .output(this.streamManager.videoFilePath)
             .on("error", this.onEnd)
             .on("end", () => this.onEnd("finished"))
@@ -116,11 +119,31 @@ export class FFMPEGRecorder extends EventEmitter {
             }
         })
             .on("stderr", this.timeoutChecker?.update);
-        if (this.hasSegment) {
-            command.outputOptions("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
-        }
         return command;
     }
+    buildOutputOptions() {
+        const options = [];
+        options.push(...this.ffmpegOutputOptions);
+        options.push("-c", "copy", "-movflags", "+frag_keyframe+empty_moov+separate_moof", "-fflags", "+genpts+igndts", "-min_frag_duration", "10000000");
+        if (this.segment) {
+            if (typeof this.segment === "number") {
+                options.push("-f", "segment", "-segment_time", String(this.segment * 60));
+            }
+            else if (typeof this.segment === "string") {
+                options.push("-fs", String(this.segment));
+            }
+            options.push("-reset_timestamps", "1");
+            if (this.videoFormat === "m4s") {
+                options.push("-segment_format", "mp4");
+            }
+        }
+        else {
+            if (this.videoFormat === "m4s") {
+                options.push("-f", "mp4");
+            }
+        }
+        return options;
+    }
     formatLine(line) {
         if (!line.includes("time=")) {
             return null;
@@ -160,4 +183,7 @@ export class FFMPEGRecorder extends EventEmitter {
     getExtraDataController() {
         return this.streamManager?.getExtraDataController();
     }
+    get videoFilePath() {
+        return this.streamManager.videoFilePath;
+    }
 }

package/lib/{recorder/IRecorder.d.ts → downloader/IDownloader.d.ts}

@@ -1,5 +1,8 @@
 import { EventEmitter } from "node:events";
+import type { VideoFormat } from "../index.js";
 import type { FormatName } from "./index.js";
+import type { XmlStreamController } from "../xml_stream_controller.js";
+export type Segment = number | string | undefined;
 /**
  * 录制器构造函数选项的基础接口
  */
@@ -9,25 +12,23 @@ export interface BaseRecorderOptions {
         startTime: number;
         title?: string;
     }) => string;
-    segment: number;
+    segment: Segment;
     inputOptions?: string[];
-    disableDanma?: boolean;
     formatName: FormatName;
     debugLevel?: "none" | "basic" | "verbose";
     headers?: {
         [key: string]: string | undefined;
     };
-    videoFormat?: "auto" | "ts" | "mkv" | "mp4";
+    videoFormat?: VideoFormat;
 }
 /**
  * 录制器接口定义
  */
-export interface IRecorder extends EventEmitter {
+export interface IDownloader extends EventEmitter {
     type: "ffmpeg" | "mesio" | "bililive";
     readonly hasSegment: boolean;
-    readonly segment: number;
+    readonly segment: Segment;
     readonly inputOptions: string[];
-    readonly disableDanma: boolean;
     readonly url: string;
     readonly headers: {
         [key: string]: string | undefined;
@@ -39,12 +40,14 @@ export interface IRecorder extends EventEmitter {
     run(): void;
     stop(): Promise<void>;
     getArguments(): string[];
-    getExtraDataController(): any;
+    getExtraDataController(): XmlStreamController | null;
     createCommand(): any;
+    get videoFilePath(): string;
     on(event: "videoFileCreated", listener: (data: {
         filename: string;
         cover?: string;
         rawFilename?: string;
+        title?: string;
     }) => void): this;
     on(event: "videoFileCompleted", listener: (data: {
         filename: string;
@@ -59,6 +62,7 @@ export interface IRecorder extends EventEmitter {
         filename: string;
         cover?: string;
         rawFilename?: string;
+        title?: string;
     }): boolean;
     emit(event: "videoFileCompleted", data: {
         filename: string;

package/lib/downloader/index.d.ts

@@ -0,0 +1,48 @@
+import { FFmpegDownloader } from "./FFmpegDownloader.js";
+import { mesioDownloader } from "./mesioDownloader.js";
+import { BililiveDownloader } from "./BililiveDownloader.js";
+export { FFmpegDownloader } from "./FFmpegDownloader.js";
+export { mesioDownloader } from "./mesioDownloader.js";
+export { BililiveDownloader } from "./BililiveDownloader.js";
+import type { IDownloader, FFMPEGRecorderOptions, MesioRecorderOptions, BililiveRecorderOptions } from "./IDownloader.js";
+/**
+ * 录制器类型
+ */
+export type DownloaderType = "ffmpeg" | "mesio" | "bililive";
+export type FormatName = "flv" | "ts" | "fmp4";
+/**
+ * 根据录制器类型获取对应的配置选项类型
+ */
+export type RecorderOptions<T extends DownloaderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : T extends "mesio" ? MesioRecorderOptions : BililiveRecorderOptions;
+/**
+ * 根据录制器类型获取对应的录制器实例类型
+ */
+export type RecorderInstance<T extends DownloaderType> = T extends "ffmpeg" ? FFmpegDownloader : T extends "mesio" ? mesioDownloader : BililiveDownloader;
+type RecorderOpts = FFMPEGRecorderOptions | MesioRecorderOptions | BililiveRecorderOptions;
+/**
+ * 创建录制器的工厂函数
+ */
+export declare function createBaseDownloader<T extends DownloaderType>(type: T, opts: RecorderOptions<T> & {
+    onlyAudio?: boolean;
+}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    title?: string;
+    cover?: string;
+}>): IDownloader;
+/**
+ * 选择录制器
+ */
+export declare function selectRecorder(preferredRecorder: "auto" | DownloaderType | undefined): DownloaderType;
+/**
+ * 判断原始录制流格式，flv, ts, m4s
+ */
+export declare function getSourceFormatName(streamUrl: string, formatName: FormatName | undefined): FormatName;
+type PickPartial<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
+/**
+ * 创建录制器的工厂函数
+ */
+export declare function createDownloader(type: "auto" | DownloaderType | undefined, opts: PickPartial<RecorderOpts, "formatName"> & {
+    onlyAudio?: boolean;
+}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    title?: string;
+    cover?: string;
+}>): IDownloader;