@openclaw/twitch 2026.5.20 → 2026.5.22

package/node_modules/@twurple/api/lib/endpoints/video/HelixVideo.d.ts

@@ -0,0 +1,105 @@
+import { DataObject } from '@twurple/common';
+import { type HelixVideoData, type HelixVideoMutedSegmentData, type HelixVideoType } from '../../interfaces/endpoints/video.external.js';
+import type { HelixUser } from '../user/HelixUser.js';
+/**
+ * A video on Twitch.
+ */
+export declare class HelixVideo extends DataObject<HelixVideoData> {
+    /**
+     * The ID of the video.
+     */
+    get id(): string;
+    /**
+     * The ID of the user who created the video.
+     */
+    get userId(): string;
+    /**
+     * The name of the user who created the video.
+     */
+    get userName(): string;
+    /**
+     * The display name of the user who created the video.
+     */
+    get userDisplayName(): string;
+    /**
+     * Gets information about the user who created the video.
+     */
+    getUser(): Promise<HelixUser>;
+    /**
+     * The title of the video.
+     */
+    get title(): string;
+    /**
+     * The description of the video.
+     */
+    get description(): string;
+    /**
+     * The date when the video was created.
+     */
+    get creationDate(): Date;
+    /**
+     * The date when the video was published.
+     */
+    get publishDate(): Date;
+    /**
+     * The URL of the video.
+     */
+    get url(): string;
+    /**
+     * The URL of the thumbnail of the video.
+     */
+    get thumbnailUrl(): string;
+    /**
+     * Builds the thumbnail URL of the video using the given dimensions.
+     *
+     * @param width The width of the thumbnail.
+     * @param height The height of the thumbnail.
+     */
+    getThumbnailUrl(width: number, height: number): string;
+    /**
+     * Whether the video is public or not.
+     */
+    get isPublic(): boolean;
+    /**
+     * The number of views of the video.
+     */
+    get views(): number;
+    /**
+     * The language of the video.
+     */
+    get language(): string;
+    /**
+     * The type of the video.
+     */
+    get type(): HelixVideoType;
+    /**
+     * The duration of the video, as formatted by Twitch.
+     */
+    get duration(): string;
+    /**
+     * The duration of the video, in seconds.
+     */
+    get durationInSeconds(): number;
+    /**
+     * The ID of the stream this video belongs to.
+     *
+     * Returns null if the video is not an archived stream.
+     */
+    get streamId(): string | null;
+    /**
+     * The raw data of muted segments of the video.
+     */
+    get mutedSegmentData(): HelixVideoMutedSegmentData[];
+    /**
+     * Checks whether the video is muted at a given offset or range.
+     *
+     * @param offset The start of your range, in seconds from the start of the video,
+     * or if no duration is given, the exact offset that is checked.
+     * @param duration The duration of your range, in seconds.
+     * @param partial Whether the range check is only partial.
+     *
+     * By default, this function returns true only if the passed range is entirely contained in a muted segment.
+     */
+    isMutedAt(offset: number, duration?: number, partial?: boolean): boolean;
+}
+//# sourceMappingURL=HelixVideo.d.ts.map

package/node_modules/@twurple/api/lib/endpoints/video/HelixVideo.js

@@ -0,0 +1,195 @@
+import { __decorate } from "tslib";
+import { Cacheable, CachedGetter } from '@d-fischer/cache-decorators';
+import { Enumerable } from '@d-fischer/shared-utils';
+import { checkRelationAssertion, DataObject, HellFreezesOverError, rawDataSymbol, rtfm } from '@twurple/common';
+/**
+ * A video on Twitch.
+ */
+let HelixVideo = class HelixVideo extends DataObject {
+    /** @internal */ _client;
+    /** @internal */
+    constructor(data, client) {
+        super(data);
+        this._client = client;
+    }
+    /**
+     * The ID of the video.
+     */
+    get id() {
+        return this[rawDataSymbol].id;
+    }
+    /**
+     * The ID of the user who created the video.
+     */
+    get userId() {
+        return this[rawDataSymbol].user_id;
+    }
+    /**
+     * The name of the user who created the video.
+     */
+    get userName() {
+        return this[rawDataSymbol].user_login;
+    }
+    /**
+     * The display name of the user who created the video.
+     */
+    get userDisplayName() {
+        return this[rawDataSymbol].user_name;
+    }
+    /**
+     * Gets information about the user who created the video.
+     */
+    async getUser() {
+        return checkRelationAssertion(await this._client.users.getUserById(this[rawDataSymbol].user_id));
+    }
+    /**
+     * The title of the video.
+     */
+    get title() {
+        return this[rawDataSymbol].title;
+    }
+    /**
+     * The description of the video.
+     */
+    get description() {
+        return this[rawDataSymbol].description;
+    }
+    /**
+     * The date when the video was created.
+     */
+    get creationDate() {
+        return new Date(this[rawDataSymbol].created_at);
+    }
+    /**
+     * The date when the video was published.
+     */
+    get publishDate() {
+        return new Date(this[rawDataSymbol].published_at);
+    }
+    /**
+     * The URL of the video.
+     */
+    get url() {
+        return this[rawDataSymbol].url;
+    }
+    /**
+     * The URL of the thumbnail of the video.
+     */
+    get thumbnailUrl() {
+        return this[rawDataSymbol].thumbnail_url;
+    }
+    /**
+     * Builds the thumbnail URL of the video using the given dimensions.
+     *
+     * @param width The width of the thumbnail.
+     * @param height The height of the thumbnail.
+     */
+    getThumbnailUrl(width, height) {
+        return this[rawDataSymbol].thumbnail_url
+            .replace('%{width}', width.toString())
+            .replace('%{height}', height.toString());
+    }
+    /**
+     * Whether the video is public or not.
+     */
+    get isPublic() {
+        return this[rawDataSymbol].viewable === 'public';
+    }
+    /**
+     * The number of views of the video.
+     */
+    get views() {
+        return this[rawDataSymbol].view_count;
+    }
+    /**
+     * The language of the video.
+     */
+    get language() {
+        return this[rawDataSymbol].language;
+    }
+    /**
+     * The type of the video.
+     */
+    get type() {
+        return this[rawDataSymbol].type;
+    }
+    /**
+     * The duration of the video, as formatted by Twitch.
+     */
+    get duration() {
+        return this[rawDataSymbol].duration;
+    }
+    /**
+     * The duration of the video, in seconds.
+     */
+    get durationInSeconds() {
+        const parts = this[rawDataSymbol].duration.match(/\d+[hms]/g);
+        if (!parts) {
+            throw new HellFreezesOverError(`Could not parse duration string: ${this[rawDataSymbol].duration}`);
+        }
+        return parts
+            .map(part => {
+            const partialMatch = /(\d+)([hms])/.exec(part);
+            if (!partialMatch) {
+                throw new HellFreezesOverError(`Could not parse partial duration string: ${part}`);
+            }
+            const [, num, unit] = partialMatch;
+            return parseInt(num, 10) * { h: 3600, m: 60, s: 1 }[unit];
+        })
+            .reduce((a, b) => a + b);
+    }
+    /**
+     * The ID of the stream this video belongs to.
+     *
+     * Returns null if the video is not an archived stream.
+     */
+    get streamId() {
+        return this[rawDataSymbol].stream_id;
+    }
+    /**
+     * The raw data of muted segments of the video.
+     */
+    get mutedSegmentData() {
+        return this[rawDataSymbol].muted_segments?.slice() ?? [];
+    }
+    /**
+     * Checks whether the video is muted at a given offset or range.
+     *
+     * @param offset The start of your range, in seconds from the start of the video,
+     * or if no duration is given, the exact offset that is checked.
+     * @param duration The duration of your range, in seconds.
+     * @param partial Whether the range check is only partial.
+     *
+     * By default, this function returns true only if the passed range is entirely contained in a muted segment.
+     */
+    isMutedAt(offset, duration, partial = false) {
+        if (this[rawDataSymbol].muted_segments === null) {
+            return false;
+        }
+        if (duration == null) {
+            return this[rawDataSymbol].muted_segments.some(seg => seg.offset <= offset && offset <= seg.offset + seg.duration);
+        }
+        const end = offset + duration;
+        if (partial) {
+            return this[rawDataSymbol].muted_segments.some(seg => {
+                const segEnd = seg.offset + seg.duration;
+                return offset < segEnd && seg.offset < end;
+            });
+        }
+        return this[rawDataSymbol].muted_segments.some(seg => {
+            const segEnd = seg.offset + seg.duration;
+            return seg.offset <= offset && end <= segEnd;
+        });
+    }
+};
+__decorate([
+    Enumerable(false)
+], HelixVideo.prototype, "_client", void 0);
+__decorate([
+    CachedGetter()
+], HelixVideo.prototype, "durationInSeconds", null);
+HelixVideo = __decorate([
+    Cacheable,
+    rtfm('api', 'HelixVideo', 'id')
+], HelixVideo);
+export { HelixVideo };

package/node_modules/@twurple/api/lib/endpoints/video/HelixVideoApi.d.ts

@@ -0,0 +1,85 @@
+import { type UserIdResolvable } from '@twurple/common';
+import { type HelixVideoData } from '../../interfaces/endpoints/video.external.js';
+import { type HelixPaginatedVideoFilter, type HelixVideoFilter } from '../../interfaces/endpoints/video.input.js';
+import { HelixPaginatedRequest } from '../../utils/pagination/HelixPaginatedRequest.js';
+import { type HelixPaginatedResult } from '../../utils/pagination/HelixPaginatedResult.js';
+import { BaseApi } from '../BaseApi.js';
+import { HelixVideo } from './HelixVideo.js';
+/**
+ * The Helix API methods that deal with videos.
+ *
+ * Can be accessed using `client.videos` on an {@link ApiClient} instance.
+ *
+ * ## Example
+ * ```ts
+ * const api = new ApiClient({ authProvider });
+ * const { data: videos } = await api.videos.getVideosByUser('125328655');
+ * ```
+ *
+ * @meta category helix
+ * @meta categorizedTitle Videos
+ */
+export declare class HelixVideoApi extends BaseApi {
+    /**
+     * Gets the video data for the given list of video IDs.
+     *
+     * @param ids The video IDs you want to look up.
+     */
+    getVideosByIds(ids: string[]): Promise<HelixVideo[]>;
+    /**
+     * Gets the video data for the given video ID.
+     *
+     * @param id The video ID you want to look up.
+     */
+    getVideoById(id: string): Promise<HelixVideo | null>;
+    /**
+     * Gets the video data for the given video ID, batching multiple calls into fewer requests as the API allows.
+     *
+     * @param id The video ID you want to look up.
+     */
+    getVideoByIdBatched(id: string): Promise<HelixVideo | null>;
+    /**
+     * Gets the videos of the given user.
+     *
+     * @param user The user you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByUser(user: UserIdResolvable, filter?: HelixPaginatedVideoFilter): Promise<HelixPaginatedResult<HelixVideo>>;
+    /**
+     * Creates a paginator for videos of the given user.
+     *
+     * @param user The user you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByUserPaginated(user: UserIdResolvable, filter?: HelixVideoFilter): HelixPaginatedRequest<HelixVideoData, HelixVideo>;
+    /**
+     * Gets the videos of the given game.
+     *
+     * @param gameId The game you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByGame(gameId: string, filter?: HelixPaginatedVideoFilter): Promise<HelixPaginatedResult<HelixVideo>>;
+    /**
+     * Creates a paginator for videos of the given game.
+     *
+     * @param gameId The game you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByGamePaginated(gameId: string, filter?: HelixVideoFilter): HelixPaginatedRequest<HelixVideoData, HelixVideo>;
+    /**
+     * Deletes videos by its IDs.
+     *
+     * @param broadcaster The broadcaster to delete the videos for.
+     * @param ids The IDs of the videos to delete.
+     */
+    deleteVideosByIds(broadcaster: UserIdResolvable, ids: string[]): Promise<void>;
+}
+//# sourceMappingURL=HelixVideoApi.d.ts.map

package/node_modules/@twurple/api/lib/endpoints/video/HelixVideoApi.js

@@ -0,0 +1,162 @@
+var HelixVideoApi_1;
+import { __decorate } from "tslib";
+import { Enumerable } from '@d-fischer/shared-utils';
+import { extractUserId, rtfm } from '@twurple/common';
+import { HelixRequestBatcher } from '../../utils/HelixRequestBatcher.js';
+import { HelixPaginatedRequest } from '../../utils/pagination/HelixPaginatedRequest.js';
+import { createPaginatedResult } from '../../utils/pagination/HelixPaginatedResult.js';
+import { createPaginationQuery } from '../../utils/pagination/HelixPagination.js';
+import { BaseApi } from '../BaseApi.js';
+import { HelixVideo } from './HelixVideo.js';
+/**
+ * The Helix API methods that deal with videos.
+ *
+ * Can be accessed using `client.videos` on an {@link ApiClient} instance.
+ *
+ * ## Example
+ * ```ts
+ * const api = new ApiClient({ authProvider });
+ * const { data: videos } = await api.videos.getVideosByUser('125328655');
+ * ```
+ *
+ * @meta category helix
+ * @meta categorizedTitle Videos
+ */
+let HelixVideoApi = HelixVideoApi_1 = class HelixVideoApi extends BaseApi {
+    /** @internal */
+    _getVideoByIdBatcher = new HelixRequestBatcher({
+        url: 'videos',
+    }, 'id', 'id', this._client, (data) => new HelixVideo(data, this._client));
+    /**
+     * Gets the video data for the given list of video IDs.
+     *
+     * @param ids The video IDs you want to look up.
+     */
+    async getVideosByIds(ids) {
+        const result = await this._getVideos('id', ids);
+        return result.data;
+    }
+    /**
+     * Gets the video data for the given video ID.
+     *
+     * @param id The video ID you want to look up.
+     */
+    async getVideoById(id) {
+        const videos = await this.getVideosByIds([id]);
+        return videos.length ? videos[0] : null;
+    }
+    /**
+     * Gets the video data for the given video ID, batching multiple calls into fewer requests as the API allows.
+     *
+     * @param id The video ID you want to look up.
+     */
+    async getVideoByIdBatched(id) {
+        return await this._getVideoByIdBatcher.request(id);
+    }
+    /**
+     * Gets the videos of the given user.
+     *
+     * @param user The user you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    async getVideosByUser(user, filter = {}) {
+        const userId = extractUserId(user);
+        return await this._getVideos('user_id', [userId], filter);
+    }
+    /**
+     * Creates a paginator for videos of the given user.
+     *
+     * @param user The user you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByUserPaginated(user, filter = {}) {
+        const userId = extractUserId(user);
+        return this._getVideosPaginated('user_id', [userId], filter);
+    }
+    /**
+     * Gets the videos of the given game.
+     *
+     * @param gameId The game you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    async getVideosByGame(gameId, filter = {}) {
+        return await this._getVideos('game_id', [gameId], filter);
+    }
+    /**
+     * Creates a paginator for videos of the given game.
+     *
+     * @param gameId The game you want to get videos from.
+     * @param filter
+     *
+     * @expandParams
+     */
+    getVideosByGamePaginated(gameId, filter = {}) {
+        return this._getVideosPaginated('game_id', [gameId], filter);
+    }
+    /**
+     * Deletes videos by its IDs.
+     *
+     * @param broadcaster The broadcaster to delete the videos for.
+     * @param ids The IDs of the videos to delete.
+     */
+    async deleteVideosByIds(broadcaster, ids) {
+        await this._client.callApi({
+            type: 'helix',
+            url: 'videos',
+            method: 'DELETE',
+            scopes: ['channel:manage:videos'],
+            userId: extractUserId(broadcaster),
+            query: {
+                id: ids,
+            },
+        });
+    }
+    /** @internal */
+    async _getVideos(filterType, filterValues, filter = {}) {
+        if (!filterValues.length) {
+            return { data: [] };
+        }
+        const result = await this._client.callApi({
+            type: 'helix',
+            url: 'videos',
+            userId: filterType === 'user_id' ? filterValues[0] : undefined,
+            query: {
+                ...HelixVideoApi_1._makeVideosQuery(filterType, filterValues, filter),
+                ...createPaginationQuery(filter),
+            },
+        });
+        return createPaginatedResult(result, HelixVideo, this._client);
+    }
+    /** @internal */
+    _getVideosPaginated(filterType, filterValues, filter = {}) {
+        return new HelixPaginatedRequest({
+            url: 'videos',
+            userId: filterType === 'user_id' ? filterValues[0] : undefined,
+            query: HelixVideoApi_1._makeVideosQuery(filterType, filterValues, filter),
+        }, this._client, data => new HelixVideo(data, this._client));
+    }
+    /** @internal */
+    static _makeVideosQuery(filterType, filterValues, filter = {}) {
+        const { language, period, orderBy, type } = filter;
+        return {
+            [filterType]: filterValues,
+            language,
+            period,
+            sort: orderBy,
+            type,
+        };
+    }
+};
+__decorate([
+    Enumerable(false)
+], HelixVideoApi.prototype, "_getVideoByIdBatcher", void 0);
+HelixVideoApi = HelixVideoApi_1 = __decorate([
+    rtfm('api', 'HelixVideoApi')
+], HelixVideoApi);
+export { HelixVideoApi };

package/node_modules/@twurple/api/lib/endpoints/whisper/HelixWhisperApi.d.ts

@@ -0,0 +1,36 @@
+import { type UserIdResolvable } from '@twurple/common';
+import { BaseApi } from '../BaseApi.js';
+/**
+ * The API methods that deal with whispers.
+ *
+ * Can be accessed using 'client.whispers' on an {@link ApiClient} instance
+ *
+ * ## Example
+ * ```ts
+ * const api = new ApiClient({ authProvider });
+ * await api.whispers.sendWhisper('61369223', '86753099', 'Howdy, partner!');
+ * ```
+ *
+ * @meta category helix
+ * @meta categorizedTitle Whispers
+ */
+export declare class HelixWhisperApi extends BaseApi {
+    /**
+     * Sends a whisper message to the specified user.
+     *
+     * NOTE: The API may silently drop whispers that it suspects of violating Twitch policies. (The API does not indicate that it dropped the whisper; it returns a 204 status code as if it succeeded).
+     *
+     * @param from The user sending the whisper. This user must have a verified phone number and must match the user in the access token.
+     * @param to The user to receive the whisper.
+     * @param message The whisper message to send. The message must not be empty.
+     *
+     * The maximum message lengths are:
+     *
+     * 500 characters if the user you're sending the message to hasn't whispered you before.
+     * 10,000 characters if the user you're sending the message to has whispered you before.
+     *
+     * Messages that exceed the maximum length are truncated.
+     */
+    sendWhisper(from: UserIdResolvable, to: UserIdResolvable, message: string): Promise<void>;
+}
+//# sourceMappingURL=HelixWhisperApi.d.ts.map

package/node_modules/@twurple/api/lib/endpoints/whisper/HelixWhisperApi.js

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { extractUserId, rtfm } from '@twurple/common';
+import { createWhisperQuery } from '../../interfaces/endpoints/whisper.external.js';
+import { BaseApi } from '../BaseApi.js';
+/**
+ * The API methods that deal with whispers.
+ *
+ * Can be accessed using 'client.whispers' on an {@link ApiClient} instance
+ *
+ * ## Example
+ * ```ts
+ * const api = new ApiClient({ authProvider });
+ * await api.whispers.sendWhisper('61369223', '86753099', 'Howdy, partner!');
+ * ```
+ *
+ * @meta category helix
+ * @meta categorizedTitle Whispers
+ */
+let HelixWhisperApi = class HelixWhisperApi extends BaseApi {
+    /**
+     * Sends a whisper message to the specified user.
+     *
+     * NOTE: The API may silently drop whispers that it suspects of violating Twitch policies. (The API does not indicate that it dropped the whisper; it returns a 204 status code as if it succeeded).
+     *
+     * @param from The user sending the whisper. This user must have a verified phone number and must match the user in the access token.
+     * @param to The user to receive the whisper.
+     * @param message The whisper message to send. The message must not be empty.
+     *
+     * The maximum message lengths are:
+     *
+     * 500 characters if the user you're sending the message to hasn't whispered you before.
+     * 10,000 characters if the user you're sending the message to has whispered you before.
+     *
+     * Messages that exceed the maximum length are truncated.
+     */
+    async sendWhisper(from, to, message) {
+        await this._client.callApi({
+            type: 'helix',
+            url: 'whispers',
+            method: 'POST',
+            userId: extractUserId(from),
+            scopes: ['user:manage:whispers'],
+            query: createWhisperQuery(from, to),
+            jsonBody: {
+                message,
+            },
+        });
+    }
+};
+HelixWhisperApi = __decorate([
+    rtfm('api', 'HelixWhisperApi')
+], HelixWhisperApi);
+export { HelixWhisperApi };

package/node_modules/@twurple/api/lib/errors/ChatMessageDroppedError.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown when a chat message is dropped and not delivered to the target channel.
+ */
+export declare class ChatMessageDroppedError extends CustomError {
+    private readonly _code;
+    constructor(broadcasterId: string, message: string | undefined, code: string | undefined);
+    get code(): string | undefined;
+}
+//# sourceMappingURL=ChatMessageDroppedError.d.ts.map

package/node_modules/@twurple/api/lib/errors/ChatMessageDroppedError.js

@@ -0,0 +1,14 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown when a chat message is dropped and not delivered to the target channel.
+ */
+export class ChatMessageDroppedError extends CustomError {
+    _code;
+    constructor(broadcasterId, message, code) {
+        super(`Chat message to channel ${broadcasterId} dropped: ${message ?? 'unknown reason'}`);
+        this._code = code;
+    }
+    get code() {
+        return this._code;
+    }
+}

package/node_modules/@twurple/api/lib/errors/ConfigError.d.ts

@@ -0,0 +1,7 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever you try using invalid values in the client configuration.
+ */
+export declare class ConfigError extends CustomError {
+}
+//# sourceMappingURL=ConfigError.d.ts.map

package/node_modules/@twurple/api/lib/errors/ConfigError.js

@@ -0,0 +1,6 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever you try using invalid values in the client configuration.
+ */
+export class ConfigError extends CustomError {
+}

package/node_modules/@twurple/api/lib/errors/StreamNotLiveError.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever you try something that requires your own stream to be live.
+ */
+export declare class StreamNotLiveError extends CustomError {
+    /** @private */
+    constructor(options?: ErrorOptions);
+}
+//# sourceMappingURL=StreamNotLiveError.d.ts.map