youtubei 0.0.1-rc.3 → 0.0.1-rc.32

package/README.md

@@ -2,11 +2,16 @@
 
 `Youtubei` is made to replace my other library [scrape-yt](https://github.com/SuspiciousLookingOwl/scrape-yt/). Instead of scrapping data from Youtube page, `youtubei` fetches data by sending a request directly to `https://www.youtube.com/youtubei/v1`, which should be faster and provide more reliable result.
 
+<b>Requires Node >= 12</b>
+
+#### [Documentation](https://youtubei.netlify.app/docs)
+
 ## Installation
 ```
 npm i youtubei
 ```
 
+
 ## Example
 ```js
 const { Client } = require("youtubei");
@@ -41,8 +46,4 @@ const run = async () => {
 };
 
 run();
-```
-
-## Documentation
-
-Coming soon.
+```

package/dist/classes/Base.d.ts

@@ -0,0 +1,10 @@
+import { Client } from ".";
+/** @hidden */
+export interface BaseAttributes {
+    id: string;
+    client: Client;
+}
+export default class Base implements BaseAttributes {
+    id: string;
+    client: Client;
+}

package/dist/classes/{client/types.js → Base.js}

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+class Base {
+}
+exports.default = Base;

package/dist/classes/BaseVideo.d.ts

@@ -0,0 +1,59 @@
+import { PlaylistCompact, VideoCompact, ChannelCompact, Base, BaseAttributes, Thumbnails } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+export interface BaseVideoAttributes extends BaseAttributes {
+    title: string;
+    thumbnails: Thumbnails;
+    description: string;
+    channel: ChannelCompact;
+    uploadDate: string;
+    viewCount: number | null;
+    likeCount: number | null;
+    isLiveContent: boolean;
+    tags: string[];
+    upNext: VideoCompact | PlaylistCompact | null;
+    related: (VideoCompact | PlaylistCompact)[];
+    relatedContinuation?: string;
+}
+/** Represents a Video  */
+export default class BaseVideo extends Base implements BaseVideoAttributes {
+    /** The title of this video */
+    title: string;
+    /** Thumbnails of the video with different sizes */
+    thumbnails: Thumbnails;
+    /** The description of this video */
+    description: string;
+    /** The channel that uploaded this video */
+    channel: ChannelCompact;
+    /** The date this video is uploaded at */
+    uploadDate: string;
+    /** How many view does this video have, null if the view count is hidden */
+    viewCount: number | null;
+    /** How many like does this video have, null if the like count hidden */
+    likeCount: number | null;
+    /** Whether this video is a live content or not */
+    isLiveContent: boolean;
+    /** The tags of this video */
+    tags: string[];
+    /** Next video / playlist recommended by Youtube */
+    upNext: VideoCompact | PlaylistCompact | null;
+    /** Videos / playlists related to this video  */
+    related: (VideoCompact | PlaylistCompact)[];
+    /** Current continuation token to load next related content  */
+    relatedContinuation?: string;
+    /** @hidden */
+    constructor(video?: Partial<BaseVideoAttributes>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): BaseVideo;
+    /** Load next related videos / playlists */
+    nextRelated(count?: number): Promise<(VideoCompact | PlaylistCompact)[]>;
+    /** @hidden */
+    static parseRawData(data: YoutubeRawData): YoutubeRawData;
+    private static parseRelated;
+    private static parseCompactRenderer;
+    private static parseButtonRenderer;
+}

package/dist/classes/BaseVideo.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const common_1 = require("../common");
+const constants_1 = require("../constants");
+/** Represents a Video  */
+class BaseVideo extends _1.Base {
+    /** @hidden */
+    constructor(video = {}) {
+        super();
+        /** Videos / playlists related to this video  */
+        this.related = [];
+        Object.assign(this, video);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        var _a, _b, _c, _d;
+        const videoInfo = BaseVideo.parseRawData(data);
+        // Basic information
+        this.id = videoInfo.videoDetails.videoId;
+        this.title = videoInfo.videoDetails.title;
+        this.uploadDate = videoInfo.dateText.simpleText;
+        this.viewCount = +videoInfo.videoDetails.viewCount || null;
+        this.isLiveContent = videoInfo.videoDetails.isLiveContent;
+        this.thumbnails = new _1.Thumbnails().load(videoInfo.videoDetails.thumbnail.thumbnails);
+        // Channel
+        const { title, thumbnail, subscriberCountText } = videoInfo.owner.videoOwnerRenderer;
+        this.channel = new _1.ChannelCompact({
+            client: this.client,
+            id: title.runs[0].navigationEndpoint.browseEndpoint.browseId,
+            name: title.runs[0].text,
+            subscriberCount: subscriberCountText === null || subscriberCountText === void 0 ? void 0 : subscriberCountText.simpleText,
+            thumbnails: new _1.Thumbnails().load(thumbnail.thumbnails),
+        });
+        // Like Count and Dislike Count
+        const topLevelButtons = videoInfo.videoActions.menuRenderer.topLevelButtons;
+        this.likeCount = common_1.stripToInt(BaseVideo.parseButtonRenderer(topLevelButtons[0]));
+        // Tags and description
+        this.tags =
+            ((_b = (_a = videoInfo.superTitleLink) === null || _a === void 0 ? void 0 : _a.runs) === null || _b === void 0 ? void 0 : _b.map((r) => r.text.trim()).filter((t) => t)) || [];
+        this.description =
+            ((_c = videoInfo.description) === null || _c === void 0 ? void 0 : _c.runs.map((d) => d.text).join("")) || "";
+        // Up Next and related videos
+        this.related = [];
+        const secondaryContents = data[3].response.contents.twoColumnWatchNextResults.secondaryResults.secondaryResults
+            .results;
+        if (secondaryContents) {
+            const upNext = ((_d = secondaryContents.find((s) => "compactAutoplayRenderer" in s)) === null || _d === void 0 ? void 0 : _d.compactAutoplayRenderer.contents[0]) || null;
+            this.upNext = upNext ? BaseVideo.parseCompactRenderer(upNext, this.client) : upNext;
+            this.related.push(...BaseVideo.parseRelated(secondaryContents, this.client));
+            // Related continuation
+            this.relatedContinuation = common_1.getContinuationFromItems(secondaryContents);
+        }
+        else {
+            this.upNext = null;
+            this.related = [];
+        }
+        return this;
+    }
+    /** Load next related videos / playlists */
+    nextRelated(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newRelated = [];
+            for (let i = 0; i < count || count == 0; i++) {
+                if (this.relatedContinuation === undefined)
+                    break;
+                const response = yield this.client.http.post(`${constants_1.I_END_POINT}/next`, {
+                    data: { continuation: this.relatedContinuation },
+                });
+                const secondaryContents = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction
+                    .continuationItems;
+                newRelated.push(...BaseVideo.parseRelated(secondaryContents, this.client));
+                this.relatedContinuation = common_1.getContinuationFromItems(secondaryContents);
+            }
+            this.related.push(...newRelated);
+            return newRelated;
+        });
+    }
+    /** @hidden */
+    static parseRawData(data) {
+        const contents = data[3].response.contents.twoColumnWatchNextResults.results.results.contents;
+        const primaryInfo = contents.find((c) => "videoPrimaryInfoRenderer" in c)
+            .videoPrimaryInfoRenderer;
+        const secondaryInfo = contents.find((c) => "videoSecondaryInfoRenderer" in c).videoSecondaryInfoRenderer;
+        const videoDetails = data[2].playerResponse.videoDetails;
+        return Object.assign(Object.assign(Object.assign({}, secondaryInfo), primaryInfo), { videoDetails });
+    }
+    static parseRelated(secondaryContents, client) {
+        return secondaryContents
+            .map((c) => BaseVideo.parseCompactRenderer(c, client))
+            .filter((c) => c !== undefined);
+    }
+    static parseCompactRenderer(data, client) {
+        if ("compactVideoRenderer" in data) {
+            return new _1.VideoCompact({ client }).load(data.compactVideoRenderer);
+        }
+        else if ("compactRadioRenderer" in data) {
+            return new _1.PlaylistCompact({ client }).load(data.compactRadioRenderer);
+        }
+    }
+    static parseButtonRenderer(data) {
+        var _a;
+        const buttonRenderer = data.toggleButtonRenderer || data.buttonRenderer;
+        const accessibilityData = (((_a = buttonRenderer.defaultText) === null || _a === void 0 ? void 0 : _a.accessibility) || buttonRenderer.accessibilityData).accessibilityData;
+        return accessibilityData.label;
+    }
+}
+exports.default = BaseVideo;

package/dist/classes/Channel.d.ts

@@ -1,37 +1,33 @@
-import { Thumbnail, YoutubeRawData } from "../common";
-import { BaseCompact, PlaylistCompact, VideoCompact } from ".";
-interface ChannelProperties {
-    id: string;
-    name: string;
-    url: string;
-    thumbnails: Thumbnail[];
-    videoCount?: number;
+import { YoutubeRawData } from "../common";
+import ChannelCompact, { ChannelCompactAttributes } from "./ChannelCompact";
+import PlaylistCompact from "./PlaylistCompact";
+import Thumbnails from "./Thumbnails";
+import VideoCompact from "./VideoCompact";
+interface Shelf {
+    title: string;
+    subtitle?: string;
+    items: ChannelCompact[] | VideoCompact[] | PlaylistCompact[];
 }
-/**
- * Represent a Youtube Channel
- */
-export default class Channel extends BaseCompact implements ChannelProperties {
-    name: string;
-    url: string;
-    videoCount?: number;
-    constructor(channel?: Partial<ChannelProperties>);
-    /**
-     * Get videos from current Channel
-     *
-     * TODO: Add continuation support
-     */
-    getVideos(): Promise<VideoCompact[]>;
-    /**
-     * Get playlists from current channel
-     *
-     * TODO: Add continuation support
-     */
-    getPlaylists(): Promise<PlaylistCompact[]>;
+/** @hidden */
+interface ChannelAttributes extends ChannelCompactAttributes {
+    banner: Thumbnails;
+    tvBanner: Thumbnails;
+    mobileBanner: Thumbnails;
+    shelves: Shelf[];
+}
+/**  Represents a Youtube Channel */
+export default class Channel extends ChannelCompact implements ChannelAttributes {
+    banner: Thumbnails;
+    mobileBanner: Thumbnails;
+    tvBanner: Thumbnails;
+    shelves: Shelf[];
+    /** @hidden */
+    constructor(channel?: Partial<ChannelAttributes>);
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
      *
-     * @param youtubeRawData raw object from youtubei
+     * @hidden
      */
-    load(youtubeRawData: YoutubeRawData): Channel;
+    load(data: YoutubeRawData): Channel;
 }
 export {};

package/dist/classes/Channel.js

@@ -1,145 +1,69 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("../common");
-var _1 = require(".");
-var constants_1 = require("../constants");
-/**
- * Represent a Youtube Channel
- */
-var Channel = /** @class */ (function (_super) {
-    __extends(Channel, _super);
-    function Channel(channel) {
-        if (channel === void 0) { channel = {}; }
-        var _this = _super.call(this) || this;
-        Object.assign(_this, channel);
-        return _this;
+const ChannelCompact_1 = __importDefault(require("./ChannelCompact"));
+const PlaylistCompact_1 = __importDefault(require("./PlaylistCompact"));
+const Thumbnails_1 = __importDefault(require("./Thumbnails"));
+const VideoCompact_1 = __importDefault(require("./VideoCompact"));
+/**  Represents a Youtube Channel */
+class Channel extends ChannelCompact_1.default {
+    /** @hidden */
+    constructor(channel = {}) {
+        super();
+        this.shelves = [];
+        this.videos = [];
+        this.playlists = [];
+        Object.assign(this, channel);
     }
     /**
-     * Get videos from current Channel
-     *
-     * TODO: Add continuation support
-     */
-    Channel.prototype.getVideos = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/browse", {
-                            browseId: this.id,
-                            params: "EgZ2aWRlb3M%3D",
-                        })];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, response.data.contents.twoColumnBrowseResultsRenderer.tabs[1].tabRenderer.content.sectionListRenderer.contents[0].itemSectionRenderer.contents[0].gridRenderer.items
-                                .filter(function (i) { return i.gridVideoRenderer; })
-                                .map(function (i) { return new _1.VideoCompact().load(i.gridVideoRenderer); })];
-                }
-            });
-        });
-    };
-    /**
-     * Get playlists from current channel
+     * Load this instance with raw data from Youtube
      *
-     * TODO: Add continuation support
+     * @hidden
      */
-    Channel.prototype.getPlaylists = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, section, gridPlaylistRenderer;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/browse", {
-                            browseId: this.id,
-                            params: "EglwbGF5bGlzdHM%3D",
-                        })];
-                    case 1:
-                        response = _a.sent();
-                        section = response.data.contents.twoColumnBrowseResultsRenderer.tabs[2].tabRenderer.content
-                            .sectionListRenderer;
-                        // Has category
-                        if ("shelfRenderer" in section.contents[0].itemSectionRenderer.contents[0]) {
-                            gridPlaylistRenderer = section.contents
-                                .map(function (c) {
-                                return c.itemSectionRenderer.contents[0].shelfRenderer.content
-                                    .horizontalListRenderer.items;
-                            })
-                                .flat();
-                        }
-                        else {
-                            gridPlaylistRenderer =
-                                section.contents[0].itemSectionRenderer.contents[0].gridRenderer.items;
-                        }
-                        return [2 /*return*/, gridPlaylistRenderer.map(function (i) {
-                                return new _1.PlaylistCompact().load(i.gridPlaylistRenderer);
-                            })];
-                }
-            });
-        });
-    };
-    /**
-     * Load instance attributes from youtube raw data
-     *
-     * @param youtubeRawData raw object from youtubei
-     */
-    Channel.prototype.load = function (youtubeRawData) {
-        var _a;
-        var channelId = youtubeRawData.channelId, title = youtubeRawData.title, thumbnail = youtubeRawData.thumbnail, videoCountText = youtubeRawData.videoCountText, navigationEndpoint = youtubeRawData.navigationEndpoint;
-        var _b = navigationEndpoint.browseEndpoint, browseId = _b.browseId, canonicalBaseUrl = _b.canonicalBaseUrl;
+    load(data) {
+        const { channelId, title, avatar, subscriberCountText, } = data.header.c4TabbedHeaderRenderer;
         this.id = channelId;
-        this.name = title.simpleText;
-        this.thumbnails = thumbnail.thumbnails;
-        this.url = "https://www.youtube.com" + (canonicalBaseUrl || "/channel/" + browseId);
-        this.videoCount = (_a = +(videoCountText === null || videoCountText === void 0 ? void 0 : videoCountText.runs[0].text.replace(/[^0-9]/g, ""))) !== null && _a !== void 0 ? _a : 0;
+        this.name = title;
+        this.thumbnails = new Thumbnails_1.default().load(avatar.thumbnails);
+        this.videoCount = 0; // data not available
+        this.subscriberCount = subscriberCountText.simpleText;
+        this.videos = [];
+        this.playlists = [];
+        const { tvBanner, mobileBanner, banner } = data.header.c4TabbedHeaderRenderer;
+        this.banner = new Thumbnails_1.default().load(banner.thumbnails);
+        this.tvBanner = new Thumbnails_1.default().load(tvBanner.thumbnails);
+        this.mobileBanner = new Thumbnails_1.default().load(mobileBanner.thumbnails);
+        // shelves
+        const rawShelves = data.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content
+            .sectionListRenderer.contents;
+        for (const rawShelf of rawShelves) {
+            const shelfRenderer = rawShelf.itemSectionRenderer.contents[0].shelfRenderer;
+            if (!shelfRenderer)
+                continue;
+            const { title, content, subtitle } = shelfRenderer;
+            if (!content.horizontalListRenderer)
+                continue;
+            const items = content.horizontalListRenderer.items
+                .map((i) => {
+                if (i.gridVideoRenderer)
+                    return new VideoCompact_1.default({ client: this.client }).load(i.gridVideoRenderer);
+                if (i.gridPlaylistRenderer)
+                    return new PlaylistCompact_1.default({ client: this.client }).load(i.gridPlaylistRenderer);
+                if (i.gridChannelRenderer)
+                    return new ChannelCompact_1.default({ client: this.client }).load(i.gridChannelRenderer);
+                return undefined;
+            })
+                .filter((i) => i !== undefined);
+            const shelf = {
+                title: title.runs[0].text,
+                subtitle: subtitle === null || subtitle === void 0 ? void 0 : subtitle.simpleText,
+                items,
+            };
+            this.shelves.push(shelf);
+        }
         return this;
-    };
-    return Channel;
-}(_1.BaseCompact));
+    }
+}
 exports.default = Channel;

package/dist/classes/ChannelCompact.d.ts

@@ -1,39 +1,90 @@
 import { YoutubeRawData } from "../common";
-import { PlaylistCompact, VideoCompact } from ".";
-interface ChannelCompactProperties {
-    id: string;
+import { Base, PlaylistCompact, Thumbnails, VideoCompact, BaseAttributes } from ".";
+/** @hidden */
+export interface ChannelCompactAttributes extends BaseAttributes {
     name: string;
-    url: string;
-    thumbnail?: string;
+    thumbnails?: Thumbnails;
     videoCount?: number;
+    subscriberCount?: string;
+    videoContinuation?: string | null;
+    playlistContinuation?: string | null;
 }
-/**
- * Represent a Youtube Channel
- */
-export default class ChannelCompact implements ChannelCompactProperties {
-    id: string;
+/**  Represents a Youtube Channel */
+export default class ChannelCompact extends Base implements ChannelCompactAttributes {
+    /** The channel's name */
     name: string;
-    url: string;
-    thumbnail?: string;
+    /** Thumbnails of the Channel with different sizes */
+    thumbnails?: Thumbnails;
+    /** How many video does this channel have */
     videoCount?: number;
-    constructor(channel?: Partial<ChannelCompactProperties>);
     /**
-     * Get videos from current Channel
+     * How many subscriber does this channel have,
      *
-     * TODO: Add continuation support
+     * This is not the exact amount, but a literal string like `"1.95M subscribers"`
      */
-    getVideos(): Promise<VideoCompact[]>;
+    subscriberCount?: string;
+    /** Loaded videos on the channel, fetched from `channel.nextVideos()` */
+    videos: VideoCompact[];
+    /** Loaded playlists on the channel, fetched from `channel.nextPlaylists()` */
+    playlists: PlaylistCompact[];
+    /** Current continuation token to load next videos */
+    videoContinuation?: string | null;
+    /** Current continuation token to load next playlists */
+    playlistContinuation?: string | null;
+    /** @hidden */
+    constructor(channel?: Partial<ChannelCompactAttributes>);
+    /** The URL of the channel page */
+    get url(): string;
     /**
-     * Get playlists from current channel
+     * Load this instance with raw data from Youtube
      *
-     * TODO: Add continuation support
+     * @hidden
      */
-    getPlaylists(): Promise<PlaylistCompact[]>;
+    load(data: YoutubeRawData): ChannelCompact;
     /**
-     * Load instance attributes from youtube raw data
+     * Load next 30 videos made by the channel, and push the loaded videos to {@link Channel.videos}
      *
-     * @param youtubeRawData raw object from youtubei
+     * @example
+     * ```js
+     * const channel = await youtube.findOne(CHANNEL_NAME, {type: "channel"});
+     * await channel.nextVideos();
+     * console.log(channel.videos) // first 30 videos
+     *
+     * let newVideos = await channel.nextVideos();
+     * console.log(newVideos) // 30 loaded videos
+     * console.log(channel.videos) // first 60 videos
+     *
+     * await channel.nextVideos(0); // load the rest of the videos in the channel
+     * ```
+     *
+     * @param count How many time to load the next videos, pass `0` to load all
+     *
+     * @return New loaded videos
+     */
+    nextVideos(count?: number): Promise<VideoCompact[]>;
+    /**
+     * Load next 30 playlists made by the channel, and push the loaded playlists to {@link Channel.playlists}
+     *
+     * @example
+     * ```js
+     * const channel = await youtube.findOne(CHANNEL_NAME, {type: "channel"});
+     * await channel.nextPlaylists();
+     * console.log(channel.playlists) // first 30 playlists
+     *
+     * let newPlaylists = await channel.nextPlaylists();
+     * console.log(newPlaylists) // 30 loaded playlists
+     * console.log(channel.playlists) // first 60 playlists
+     *
+     * await channel.nextPlaylists(0); // load the rest of the playlists in the channel
+     * ```
+     *
+     * @param count How many time to load the next playlists, pass `0` to load all
+     *
+     * @return New loaded playlists
      */
-    load(youtubeRawData: YoutubeRawData): ChannelCompact;
+    nextPlaylists(count?: number): Promise<PlaylistCompact[]>;
+    /** Get tab data from youtube */
+    private getTabData;
+    /** Parse tab data from request, tab name is ignored if it's a continuation data */
+    private static parseTabData;
 }
-export {};