youtubei 0.0.1-rc.8 → 1.0.0-rc.2

package/dist/typings/classes/Client/HTTP.d.ts

@@ -0,0 +1,21 @@
+import { RequestInit } from "node-fetch";
+import { ClientOptions } from "./Client";
+declare type Response<T = any> = {
+    data: T;
+};
+declare type Options = {
+    data: Record<string, unknown>;
+    params: Record<string, string>;
+} & RequestInit;
+export declare class HTTP {
+    private cookie;
+    private defaultHeaders;
+    private defaultFetchOptions;
+    private defaultClientOptions;
+    constructor(options: ClientOptions);
+    get(url: string, options?: Partial<Options>): Promise<Response>;
+    post(url: string, options?: Partial<Options>): Promise<Response>;
+    private request;
+    private parseCookie;
+}
+export {};

package/dist/typings/classes/Client/index.d.ts

@@ -0,0 +1 @@
+export * from "./Client";

package/dist/typings/classes/Comment/Comment.d.ts

@@ -0,0 +1,51 @@
+import { YoutubeRawData } from "../../common";
+import { Base, BaseProperties } from "../Base";
+import { BaseChannel } from "../BaseChannel";
+import { Video } from "../Video";
+import { CommentReplies } from "./CommentReplies";
+/** @hidden */
+interface CommentProperties extends BaseProperties {
+    id?: string;
+    video?: Video;
+    author?: BaseChannel;
+    content?: string;
+    publishDate?: string;
+    likeCount?: number;
+    isAuthorChannelOwner?: boolean;
+    isPinned?: boolean;
+    replyCount?: number;
+    replies?: CommentReplies;
+}
+/** Represents a Comment / Reply */
+export declare class Comment extends Base implements CommentProperties {
+    id: string;
+    /** The video this comment belongs to */
+    video: Video;
+    /** The comment's author */
+    author: BaseChannel;
+    /** The content of this comment */
+    content: string;
+    /** The publish date of the comment */
+    publishDate: string;
+    /** How many likes does this comment have */
+    likeCount: number;
+    /** Whether the comment is posted by the video uploader / owner */
+    isAuthorChannelOwner: boolean;
+    /** Whether the comment is pinned */
+    isPinned: boolean;
+    /** Reply count of this comment */
+    replyCount: number;
+    /** Continuable of replies in this comment */
+    replies: CommentReplies;
+    /** @hidden */
+    constructor(attr: CommentProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Comment;
+    /** URL to the video with this comment being highlighted (appears on top of the comment section) */
+    get url(): string;
+}
+export {};

package/dist/typings/classes/Comment/CommentParser.d.ts

@@ -0,0 +1,8 @@
+import { YoutubeRawData } from "../../common";
+import { Reply } from "../Reply";
+import { Comment } from "./Comment";
+export declare class CommentParser {
+    static loadComment(target: Comment, data: YoutubeRawData): Comment;
+    static parseContinuation(data: YoutubeRawData): string | undefined;
+    static parseReplies(data: YoutubeRawData, comment: Comment): Reply[];
+}

package/dist/typings/classes/Comment/CommentReplies.d.ts

@@ -0,0 +1,17 @@
+import { Continuable, ContinuableConstructorParams, FetchResult } from "../Continuable";
+import { Reply } from "../Reply";
+import { Comment } from "./Comment";
+declare type ConstructorParams = ContinuableConstructorParams & {
+    comment: Comment;
+};
+/**
+ * {@link Continuable} of replies inside a {@link Comment}
+ */
+export declare class CommentReplies extends Continuable<Reply> {
+    /** The comment this replies belongs to */
+    comment: Comment;
+    /** @hidden */
+    constructor({ client, comment }: ConstructorParams);
+    protected fetch(): Promise<FetchResult<Reply>>;
+}
+export {};

package/dist/typings/classes/Comment/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Comment";
+export * from "./CommentReplies";
+export * from "./CommentParser";

package/dist/typings/classes/Continuable/Continuable.d.ts

@@ -0,0 +1,24 @@
+import { Base } from "../Base";
+import { Client } from "../Client";
+/** @hidden */
+export declare type FetchResult<T> = {
+    items: T[];
+    continuation?: string;
+};
+/** @hidden */
+export declare type ContinuableConstructorParams = {
+    client: Client;
+    strictContinuationCheck?: boolean;
+};
+/** Represents a continuable list of items `T` (like pagination) */
+export declare abstract class Continuable<T> extends Base {
+    items: T[];
+    continuation?: string | null;
+    private strictContinuationCheck;
+    /** @hidden */
+    constructor({ client, strictContinuationCheck }: ContinuableConstructorParams);
+    /** Fetch next items using continuation token */
+    next(count?: number): Promise<T[]>;
+    protected abstract fetch(): Promise<FetchResult<T>>;
+    private get hasContinuation();
+}

package/dist/typings/classes/Continuable/index.d.ts

@@ -0,0 +1 @@
+export * from "./Continuable";

package/dist/typings/classes/LiveVideo/LiveVideo.d.ts

@@ -0,0 +1,46 @@
+import { YoutubeRawData } from "../../common";
+import { BaseVideo, BaseVideoProperties } from "../BaseVideo";
+import { Chat } from "../Chat";
+/** @hidden */
+interface LiveVideoProperties extends BaseVideoProperties {
+    watchingCount?: number;
+    chatContinuation?: string;
+}
+interface LiveVideoEvents {
+    chat: (chat: Chat) => void;
+}
+declare interface LiveVideo {
+    on<T extends keyof LiveVideoEvents>(event: T, listener: LiveVideoEvents[T]): AsyncIterableIterator<any>;
+    emit<T extends keyof LiveVideoEvents>(event: T, ...args: Parameters<LiveVideoEvents[T]>): boolean;
+}
+/** Represents a video that's currently live, usually returned from `client.getVideo()` */
+declare class LiveVideo extends BaseVideo implements LiveVideoProperties {
+    /** Number of people who's watching the live stream right now */
+    watchingCount: number;
+    /** Current continuation token to load next chat  */
+    chatContinuation: string;
+    private _delay;
+    private _chatRequestPoolingTimeout;
+    private _timeoutMs;
+    private _isChatPlaying;
+    private _chatQueue;
+    /** @hidden */
+    constructor(attr: LiveVideoProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): LiveVideo;
+    /**
+     * Start polling for get live chat request
+     *
+     * @param delay chat delay in millisecond
+     */
+    playChat(delay?: number): void;
+    /** Stop request polling for live chat */
+    stopChat(): void;
+    /** Start request polling */
+    private pollChatContinuation;
+}
+export { LiveVideo };

package/dist/typings/classes/LiveVideo/LiveVideoParser.d.ts

@@ -0,0 +1,10 @@
+import { YoutubeRawData } from "../../common";
+import { LiveVideo } from "./LiveVideo";
+export declare class LiveVideoParser {
+    static loadLiveVideo(target: LiveVideo, data: YoutubeRawData): LiveVideo;
+    static parseChats(data: YoutubeRawData): YoutubeRawData[];
+    static parseContinuation(data: YoutubeRawData): {
+        continuation: string;
+        timeout: number;
+    };
+}

package/dist/typings/classes/LiveVideo/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LiveVideo";
+export * from "./LiveVideoParser";

package/dist/typings/classes/MixPlaylist/MixPlaylist.d.ts

@@ -0,0 +1,29 @@
+import { YoutubeRawData } from "../../common";
+import { Base, BaseProperties } from "../Base";
+import { VideoCompact } from "../VideoCompact";
+/** @hidden */
+interface MixPlaylistProperties extends BaseProperties {
+    id?: string;
+    title?: string;
+    videoCount?: number;
+    videos?: VideoCompact[];
+}
+/** Represents a MixPlaylist, usually returned from `client.getPlaylist()` */
+export declare class MixPlaylist extends Base implements MixPlaylistProperties {
+    id: string;
+    /** The title of this playlist */
+    title: string;
+    /** How many videos in this playlist */
+    videoCount: number;
+    /** How many viewers does this playlist have */
+    videos: VideoCompact[];
+    /** @hidden */
+    constructor(attr: MixPlaylistProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): MixPlaylist;
+}
+export {};

package/dist/typings/classes/MixPlaylist/MixPlaylistParser.d.ts

@@ -0,0 +1,6 @@
+import { YoutubeRawData } from "../../common";
+import { MixPlaylist } from "./MixPlaylist";
+export declare class MixPlaylistParser {
+    static loadMixPlaylist(target: MixPlaylist, data: YoutubeRawData): MixPlaylist;
+    private static parseVideos;
+}

package/dist/typings/classes/MixPlaylist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MixPlaylist";
+export * from "./MixPlaylistParser";

package/dist/typings/classes/Playlist/Playlist.d.ts

@@ -0,0 +1,39 @@
+import { YoutubeRawData } from "../../common";
+import { Base, BaseProperties } from "../Base";
+import { BaseChannel, BaseChannelProperties } from "../BaseChannel";
+import { PlaylistVideos } from "./PlaylistVideos";
+/** @hidden */
+interface PlaylistProperties extends BaseProperties {
+    id?: string;
+    title?: string;
+    videoCount?: number;
+    viewCount?: number;
+    lastUpdatedAt?: string;
+    channel?: BaseChannelProperties;
+    videos?: PlaylistVideos;
+}
+/** Represents a Playlist, usually returned from `client.getPlaylist()` */
+export declare class Playlist extends Base implements PlaylistProperties {
+    id: string;
+    /** The title of this playlist */
+    title: string;
+    /** How many videos in this playlist */
+    videoCount: number;
+    /** How many viewers does this playlist have */
+    viewCount: number;
+    /** Last time this playlist is updated */
+    lastUpdatedAt: string;
+    /** The channel that made this playlist */
+    channel?: BaseChannel;
+    /** Continuable of videos in this playlist */
+    videos: PlaylistVideos;
+    /** @hidden */
+    constructor(attr: PlaylistProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Playlist;
+}
+export {};

package/dist/typings/classes/Playlist/PlaylistParser.d.ts

@@ -0,0 +1,16 @@
+import { YoutubeRawData } from "../../common";
+import { Client } from "../Client";
+import { VideoCompact } from "../VideoCompact";
+import { Playlist } from "./Playlist";
+export declare class PlaylistParser {
+    static loadPlaylist(target: Playlist, data: YoutubeRawData): Playlist;
+    static parseVideoContinuation(data: YoutubeRawData): string | undefined;
+    static parseContinuationVideos(data: YoutubeRawData, client: Client): VideoCompact[];
+    /**
+     * Get compact videos
+     *
+     * @param playlistContents raw object from youtubei
+     */
+    private static parseVideos;
+    private static parseSideBarInfo;
+}

package/dist/typings/classes/Playlist/PlaylistVideos.d.ts

@@ -0,0 +1,31 @@
+import { Continuable, ContinuableConstructorParams, FetchResult } from "../Continuable";
+import { VideoCompact } from "../VideoCompact";
+import { Playlist } from "./Playlist";
+declare type ConstructorParams = ContinuableConstructorParams & {
+    playlist?: Playlist;
+};
+/**
+ * {@link Continuable} of videos inside a {@link Playlist}
+ *
+ * @example
+ * ```js
+ * const playlist = await youtube.getPlaylist(PLAYLIST_ID);
+ * console.log(playlist.videos) // first 100 videos
+ *
+ * let newVideos = await playlist.videos.next();
+ * console.log(newVideos) // 100 loaded videos
+ * console.log(playlist.videos) // first 200 videos
+ *
+ * await playlist.videos.next(0); // load the rest of the videos in the playlist
+ * ```
+ *
+ * @param count How many times to load the next videos. Set 0 to load all videos (might take a while on a large playlist!)
+ */
+export declare class PlaylistVideos extends Continuable<VideoCompact> {
+    /** The playlist this videos belongs to */
+    playlist?: Playlist;
+    /** @hidden */
+    constructor({ client, playlist }: ConstructorParams);
+    protected fetch(): Promise<FetchResult<VideoCompact>>;
+}
+export {};

package/dist/typings/classes/Playlist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Playlist";
+export * from "./PlaylistParser";
+export * from "./PlaylistVideos";

package/dist/typings/classes/PlaylistCompact/PlaylistCompact.d.ts

@@ -0,0 +1,43 @@
+import { YoutubeRawData } from "../../common";
+import { Base, BaseProperties } from "../Base";
+import { BaseChannel } from "../BaseChannel";
+import { Playlist } from "../Playlist/Playlist";
+import { Thumbnails } from "../Thumbnails";
+/** @hidden */
+interface PlaylistCompactProperties extends BaseProperties {
+    id?: string;
+    title?: string;
+    thumbnails?: Thumbnails;
+    channel?: BaseChannel;
+    videoCount?: number;
+}
+/** Represents a Compact Playlist (e.g. from search result, related of a video) */
+export declare class PlaylistCompact extends Base implements PlaylistCompactProperties {
+    id: string;
+    /** The playlist's title */
+    title: string;
+    /** Thumbnails of the playlist with different sizes */
+    thumbnails: Thumbnails;
+    /** The channel that made this playlist */
+    channel?: BaseChannel;
+    /** How many videos in this playlist */
+    videoCount: number;
+    /** @hidden */
+    constructor(attr: PlaylistCompactProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): PlaylistCompact;
+    /**
+     * Get {@link Playlist} object based on current playlist id
+     *
+     * Equivalent to
+     * ```js
+     * client.getPlaylist(playlistCompact.id);
+     * ```
+     */
+    getPlaylist(): Promise<Playlist>;
+}
+export {};

package/dist/typings/classes/PlaylistCompact/PlaylistCompactParser.d.ts

@@ -0,0 +1,5 @@
+import { YoutubeRawData } from "../../common";
+import { PlaylistCompact } from "./PlaylistCompact";
+export declare class PlaylistCompactParser {
+    static loadPlaylistCompact(target: PlaylistCompact, data: YoutubeRawData): PlaylistCompact;
+}

package/dist/typings/classes/PlaylistCompact/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./PlaylistCompact";
+export * from "./PlaylistCompactParser";

package/dist/typings/classes/Reply/Reply.d.ts

@@ -0,0 +1,43 @@
+import { YoutubeRawData } from "../../common";
+import { Base, BaseProperties } from "../Base";
+import { BaseChannel } from "../BaseChannel";
+import { Comment } from "../Comment";
+import { Video } from "../Video";
+/** @hidden */
+interface ReplyProperties extends BaseProperties {
+    id?: string;
+    comment?: Comment;
+    video?: Video;
+    author?: BaseChannel;
+    content?: string;
+    publishDate?: string;
+    likeCount?: number;
+    isAuthorChannelOwner?: boolean;
+}
+/** Represents a Reply */
+export declare class Reply extends Base implements ReplyProperties {
+    id: string;
+    /** The comment this reply belongs to */
+    comment: Comment;
+    /** The video this reply belongs to */
+    video: Video;
+    /** The comment's author */
+    author: BaseChannel;
+    /** The content of this comment */
+    content: string;
+    /** The publish date of the comment */
+    publishDate: string;
+    /** How many likes does this comment have */
+    likeCount: number;
+    /** Whether the comment is posted by the video uploader / owner */
+    isAuthorChannelOwner: boolean;
+    /** @hidden */
+    constructor(attr: ReplyProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Reply;
+}
+export {};

package/dist/typings/classes/Reply/ReplyParser.d.ts

@@ -0,0 +1,5 @@
+import { YoutubeRawData } from "../../common";
+import { Reply } from "./Reply";
+export declare class ReplyParser {
+    static loadReply(target: Reply, data: YoutubeRawData): Reply;
+}

package/dist/typings/classes/Reply/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Reply";
+export * from "./ReplyParser";

package/dist/typings/classes/SearchResult/SearchResult.d.ts

@@ -0,0 +1,53 @@
+import { BaseChannel } from "../BaseChannel";
+import { Continuable, ContinuableConstructorParams, FetchResult } from "../Continuable";
+import { PlaylistCompact } from "../PlaylistCompact";
+import { VideoCompact } from "../VideoCompact";
+export declare type SearchOptions = {
+    type?: SearchType;
+    duration?: SearchDuration;
+    uploadDate?: SearchUploadDate;
+    sortBy?: SearchSort;
+};
+export declare type SearchUploadDate = "all" | "hour" | "today" | "week" | "month" | "year";
+export declare type SearchType = "all" | "video" | "channel" | "playlist";
+export declare type SearchDuration = "all" | "short" | "medium" | "long";
+export declare type SearchSort = "relevance" | "rating" | "date" | "view";
+export declare type SearchResultItem<T = "all"> = T extends "video" | VideoCompact ? VideoCompact : T extends "channel" | BaseChannel ? BaseChannel : T extends "playlist" | PlaylistCompact ? PlaylistCompact : VideoCompact | BaseChannel | PlaylistCompact;
+/**
+ * Represents search result, usually returned from `client.search();`.
+ *
+ * {@link SearchResult} is a helper class to manage search result
+ *
+ * @example
+ * ```ts
+ * const result = await youtube.search("Keyword");
+ *
+ * console.log(result.items); // search result from first page
+ *
+ * let nextSearchResult = await result.next();
+ * console.log(nextSearchResult); // search result from second page
+ *
+ * nextSearchResult = await result.next();
+ * console.log(nextSearchResult); // search result from third page
+ *
+ * console.log(result.items); // search result from first, second, and third page.
+ * ```
+ *
+ * @noInheritDoc
+ */
+export declare class SearchResult<T extends SearchType | undefined = "all"> extends Continuable<SearchResultItem<T>> {
+    /** The estimated search result count */
+    estimatedResults: number;
+    /** @hidden */
+    constructor({ client }: ContinuableConstructorParams);
+    /**
+     * Initialize data from search
+     *
+     * @param query Search query
+     * @param options Search Options
+     *
+     * @hidden
+     */
+    search(query: string, options: SearchOptions): Promise<SearchResult<T>>;
+    protected fetch(): Promise<FetchResult<SearchResultItem<T>>>;
+}

package/dist/typings/classes/SearchResult/SearchResultParser.d.ts

@@ -0,0 +1,13 @@
+import { YoutubeRawData } from "../../common";
+import { Client } from "../Client";
+import { SearchResultItem } from "./SearchResult";
+declare type ParseReturnType = {
+    data: SearchResultItem[];
+    continuation: string | undefined;
+};
+export declare class SearchResultParser {
+    static parseInitialSearchResult(data: YoutubeRawData, client: Client): ParseReturnType;
+    static parseContinuationSearchResult(data: YoutubeRawData, client: Client): ParseReturnType;
+    private static parseSearchResult;
+}
+export {};

package/dist/typings/classes/SearchResult/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SearchResult";
+export * from "./SearchResultParser";

package/dist/typings/classes/SearchResult/proto/SearchProto.d.ts

@@ -0,0 +1,13 @@
+declare type Options = {
+    uploadDate?: number;
+    type?: number;
+    duration?: number;
+};
+declare type SearchOptions = {
+    sortBy?: number;
+    options?: Options;
+};
+export declare type SearchProto = {
+    SearchOptions: SearchOptions;
+};
+export {};

package/dist/typings/classes/SearchResult/proto/index.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { SearchOptions } from "../SearchResult";
+import { SearchProto as ProtoType } from "./SearchProto";
+export declare const SearchProto: {
+    SearchOptions: {
+        encode: (obj: {
+            sortBy?: number | undefined;
+            options?: {
+                uploadDate?: number | undefined;
+                type?: number | undefined;
+                duration?: number | undefined;
+            } | undefined;
+        }) => Buffer;
+        decode: (buf: Buffer) => {
+            sortBy?: number | undefined;
+            options?: {
+                uploadDate?: number | undefined;
+                type?: number | undefined;
+                duration?: number | undefined;
+            } | undefined;
+        };
+    };
+};
+export declare const optionsToProto: (options: SearchOptions) => ProtoType["SearchOptions"];

package/dist/typings/classes/Thumbnails/Thumbnails.d.ts

@@ -0,0 +1,41 @@
+export interface Thumbnail {
+    url: string;
+    width: number;
+    height: number;
+}
+/**
+ * Represents Thumbnails, usually found inside Playlist / Channel / Video, etc.
+ *
+ * {@link Thumbnails} is an array of {@link Thumbnail}
+ *
+ * @noInheritDoc
+ */
+export declare class Thumbnails extends Array<Thumbnail> {
+    /** @hidden */
+    constructor();
+    /**
+     * Returns thumbnail with the lowest resolution, usually the first element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get min(): string | undefined;
+    /**
+     * Returns thumbnail with the highest resolution, usually the last element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get best(): string | undefined;
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(thumbnails: Thumbnail[]): Thumbnails;
+    private static parseThumbnailUrl;
+}

package/dist/typings/classes/Thumbnails/index.d.ts

@@ -0,0 +1 @@
+export * from "./Thumbnails";

package/dist/typings/classes/Video/Video.d.ts

@@ -0,0 +1,24 @@
+import { YoutubeRawData } from "../../common";
+import { BaseVideo, BaseVideoProperties } from "../BaseVideo";
+import { VideoComments } from "./VideoComments";
+/** @hidden */
+interface VideoProperties extends BaseVideoProperties {
+    duration?: number;
+    comments?: VideoComments;
+}
+/** Represents a Video, usually returned from `client.getVideo()`  */
+export declare class Video extends BaseVideo implements VideoProperties {
+    /** The duration of this video in second */
+    duration: number;
+    /** {@link Continuable} of videos inside a {@link Video} */
+    comments: VideoComments;
+    /** @hidden */
+    constructor(attr: VideoProperties);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Video;
+}
+export {};