@openclaw/twitch 2026.5.20 → 2026.5.22

package/node_modules/@twurple/api/lib/utils/pagination/HelixPaginatedRequest.js

@@ -0,0 +1,140 @@
+import { __decorate } from "tslib";
+import { Enumerable } from '@d-fischer/shared-utils';
+import { rtfm } from '@twurple/common';
+if (!Object.prototype.hasOwnProperty.call(Symbol, 'asyncIterator')) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unnecessary-condition,@typescript-eslint/no-unsafe-member-access
+    Symbol.asyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
+}
+/**
+ * Represents a request to the new Twitch API (Helix) that utilizes a cursor to paginate through its results.
+ *
+ * Aside from the methods described below, you can also utilize the async iterator using `for await .. of`:
+ *
+ * ```ts
+ * const result = client.videos.getVideosByUserPaginated('125328655');
+ * for await (const video of result) {
+ *     console.log(video.title);
+ * }
+ * ```
+ */
+let HelixPaginatedRequest = class HelixPaginatedRequest {
+    _callOptions;
+    _mapper;
+    _limitPerPage;
+    /** @internal */ _client;
+    /** @internal */ _currentCursor;
+    /** @internal */ _isFinished = false;
+    /** @internal */ _currentData;
+    /** @internal */
+    constructor(_callOptions, client, _mapper, _limitPerPage = 100) {
+        this._callOptions = _callOptions;
+        this._mapper = _mapper;
+        this._limitPerPage = _limitPerPage;
+        this._client = client;
+    }
+    /**
+     * The last fetched page of data associated to the requested resource.
+     *
+     * Only works with {@link HelixPaginatedRequest#getNext} and not with any other methods of data fetching.
+     */
+    get current() {
+        return this._currentData?.data;
+    }
+    /**
+     * Gets the next available page of data associated to the requested resource, or an empty array if there are no more available pages.
+     */
+    async getNext() {
+        if (this._isFinished) {
+            return [];
+        }
+        const result = await this._fetchData();
+        // should never be null, but in practice is sometimes
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!result.data?.length) {
+            this._isFinished = true;
+            return [];
+        }
+        return this._processResult(result);
+    }
+    /**
+     * Gets all data associated to the requested resource.
+     *
+     * Be aware that this makes multiple calls to the Twitch API. Due to this, you might be more suspectible to rate limits.
+     *
+     * Also be aware that this resets the internal cursor, so avoid using this and {@link HelixPaginatedRequest#getNext}} together.
+     */
+    async getAll() {
+        this.reset();
+        const result = [];
+        do {
+            const data = await this.getNext();
+            if (!data.length) {
+                break;
+            }
+            result.push(...data);
+        } while (this._currentCursor);
+        this.reset();
+        return result;
+    }
+    /**
+     * Gets the current cursor.
+     *
+     * Only useful if you want to make manual requests to the API.
+     */
+    get currentCursor() {
+        return this._currentCursor;
+    }
+    /**
+     * Resets the internal cursor.
+     *
+     * This will make {@link HelixPaginatedRequest#getNext}} start from the first page again.
+     */
+    reset() {
+        this._currentCursor = undefined;
+        this._isFinished = false;
+        this._currentData = undefined;
+    }
+    async *[Symbol.asyncIterator]() {
+        this.reset();
+        while (true) {
+            const data = await this.getNext();
+            if (!data.length) {
+                break;
+            }
+            yield* data[Symbol.iterator]();
+        }
+    }
+    /** @internal */
+    async _fetchData(additionalOptions = {}) {
+        return await this._client.callApi({
+            type: 'helix',
+            ...this._callOptions,
+            ...additionalOptions,
+            query: {
+                ...this._callOptions.query,
+                after: this._currentCursor,
+                first: this._limitPerPage.toString(),
+                ...additionalOptions.query,
+            },
+        });
+    }
+    /** @internal */
+    _processResult(result) {
+        this._currentCursor = typeof result.pagination === 'string' ? result.pagination : result.pagination?.cursor;
+        if (this._currentCursor === undefined) {
+            this._isFinished = true;
+        }
+        this._currentData = result;
+        return result.data.reduce((acc, elem) => {
+            const mapped = this._mapper(elem);
+            return Array.isArray(mapped) ? [...acc, ...mapped] : [...acc, mapped];
+        }, []);
+    }
+};
+__decorate([
+    Enumerable(false)
+], HelixPaginatedRequest.prototype, "_client", void 0);
+HelixPaginatedRequest = __decorate([
+    rtfm('api', 'HelixPaginatedRequest')
+], HelixPaginatedRequest);
+export { HelixPaginatedRequest };

package/node_modules/@twurple/api/lib/utils/pagination/HelixPaginatedRequestWithTotal.d.ts

@@ -0,0 +1,13 @@
+import { HelixPaginatedRequest } from './HelixPaginatedRequest.js';
+/**
+ * A special case of {@link HelixPaginatedRequest} with support for fetching the total number of entities, whenever an endpoint supports it.
+ *
+ * @inheritDoc
+ */
+export declare class HelixPaginatedRequestWithTotal<D, T> extends HelixPaginatedRequest<D, T> {
+    /**
+     * Gets the total number of entities existing in the queried result set.
+     */
+    getTotalCount(): Promise<number>;
+}
+//# sourceMappingURL=HelixPaginatedRequestWithTotal.d.ts.map

package/node_modules/@twurple/api/lib/utils/pagination/HelixPaginatedRequestWithTotal.js

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { rtfm } from '@twurple/common';
+import { HelixPaginatedRequest } from './HelixPaginatedRequest.js';
+/**
+ * A special case of {@link HelixPaginatedRequest} with support for fetching the total number of entities, whenever an endpoint supports it.
+ *
+ * @inheritDoc
+ */
+let HelixPaginatedRequestWithTotal = class HelixPaginatedRequestWithTotal extends HelixPaginatedRequest {
+    /**
+     * Gets the total number of entities existing in the queried result set.
+     */
+    async getTotalCount() {
+        const data = this._currentData ??
+            (await this._fetchData({ query: { after: undefined } }));
+        return data.total;
+    }
+};
+HelixPaginatedRequestWithTotal = __decorate([
+    rtfm('api', 'HelixPaginatedRequestWithTotal')
+], HelixPaginatedRequestWithTotal);
+export { HelixPaginatedRequestWithTotal };

package/node_modules/@twurple/api/lib/utils/pagination/HelixPaginatedResult.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A result coming from a Helix resource that is paginated using a cursor.
+ */
+export interface HelixPaginatedResult<T> {
+    /**
+     * The returned data.
+     */
+    readonly data: T[];
+    /**
+     * A cursor for traversing more results.
+     */
+    cursor?: string;
+}
+/**
+ * A result coming from a Helix resource that is paginated using a cursor, also including a total number of items.
+ */
+export interface HelixPaginatedResultWithTotal<T> {
+    /**
+     * The returned data.
+     */
+    readonly data: T[];
+    /**
+     * A cursor for traversing more results.
+     */
+    cursor: string;
+    /**
+     * The total number of items.
+     */
+    total: number;
+}
+//# sourceMappingURL=HelixPaginatedResult.d.ts.map

package/node_modules/@twurple/api/lib/utils/pagination/HelixPaginatedResult.js

@@ -0,0 +1,19 @@
+/** @internal */ export function createPaginatedResult(response, type, client) {
+    let dataCache = undefined;
+    return {
+        get data() {
+            return (dataCache ??= response.data?.map(data => new type(data, client)) ?? []);
+        },
+        cursor: typeof response.pagination === 'string' ? response.pagination : response.pagination?.cursor,
+    };
+}
+/** @internal */ export function createPaginatedResultWithTotal(response, type, client) {
+    let dataCache = undefined;
+    return {
+        get data() {
+            return (dataCache ??= response.data?.map(data => new type(data, client)) ?? []);
+        },
+        cursor: response.pagination.cursor,
+        total: response.total,
+    };
+}

package/node_modules/@twurple/api/lib/utils/pagination/HelixPagination.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base forward pagination parameters for Helix requests.
+ */
+export interface HelixForwardPagination {
+    /**
+     * The number of results per page.
+     */
+    limit?: number;
+    /**
+     * A cursor to get the following page of.
+     */
+    after?: string;
+}
+/**
+ * Base pagination parameters for Helix requests.
+ *
+ * @inheritDoc
+ */
+export interface HelixPagination extends HelixForwardPagination {
+    /**
+     * A cursor to get the previous page of.
+     */
+    before?: string;
+}
+//# sourceMappingURL=HelixPagination.d.ts.map

package/node_modules/@twurple/api/lib/utils/pagination/HelixPagination.js

@@ -0,0 +1,8 @@
+/** @internal */
+export function createPaginationQuery({ after, before, limit } = {}) {
+    return {
+        after,
+        before,
+        first: limit?.toString(),
+    };
+}

package/node_modules/@twurple/api/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@twurple/api",
+  "version": "8.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Interact with Twitch's API.",
+  "keywords": [
+    "twitch",
+    "api",
+    "stream",
+    "helix",
+    "chatters",
+    "bot"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "lib",
+  "types": "lib",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/twurple/twurple.git",
+    "directory": "packages/api"
+  },
+  "homepage": "https://twurple.js.org",
+  "author": "Daniel Fischer <daniel@d-fischer.dev>",
+  "funding": "https://github.com/sponsors/d-fischer",
+  "license": "MIT",
+  "dependencies": {
+    "@d-fischer/cache-decorators": "^4.0.0",
+    "@d-fischer/detect-node": "^3.0.1",
+    "@d-fischer/logger": "^4.2.1",
+    "@d-fischer/rate-limiter": "^1.1.0",
+    "@d-fischer/shared-utils": "^3.6.1",
+    "@d-fischer/typed-event-emitter": "^3.3.3",
+    "@twurple/api-call": "8.1.4",
+    "@twurple/common": "8.1.4",
+    "retry": "^0.13.1",
+    "tslib": "^2.0.3"
+  },
+  "devDependencies": {
+    "@twurple/auth": "8.1.4",
+    "@types/retry": "^0.12.2"
+  },
+  "peerDependencies": {
+    "@twurple/auth": "8.1.4"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib",
+    "!lib/**/*.d.ts.map"
+  ]
+}

package/node_modules/@twurple/api-call/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Daniel Fischer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@twurple/api-call/README.md

@@ -0,0 +1,9 @@
+# Twurple - API call
+
+A basic Twitch API call wrapper.
+
+This is mostly intended for internal use in the other packages of [Twurple](https://github.com/twurple/twurple).
+
+## If you're getting stuck...
+
+You can join the [Twitch API Libraries Discord Server](https://discord.gg/b9ZqMfz) and ask in `#twurple` for support.

package/node_modules/@twurple/api-call/lib/HelixResponse.d.ts

@@ -0,0 +1,15 @@
+/** @private */
+export interface HelixResponse<T> {
+    data: T[];
+}
+/** @private */
+export interface HelixPaginatedResponse<T> extends HelixResponse<T> {
+    pagination?: string | {
+        cursor?: string;
+    };
+}
+/** @private */
+export interface HelixPaginatedResponseWithTotal<T> extends HelixPaginatedResponse<T> {
+    total: number;
+}
+//# sourceMappingURL=HelixResponse.d.ts.map

package/node_modules/@twurple/api-call/lib/HelixResponse.js

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

package/node_modules/@twurple/api-call/lib/TwitchApiCallOptions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The endpoint to call, i.e. /helix or a custom (potentially unsupported) endpoint.
+ */
+export type TwitchApiCallType = 'helix' | 'auth' | 'custom';
+/**
+ * Configuration for a single API call.
+ */
+export interface TwitchApiCallOptions {
+    /**
+     * The URL to request.
+     *
+     * If `type` is not `'custom'`, this is relative to the respective API root endpoint. Otherwise, it is an absolute URL.
+     */
+    url: string;
+    /**
+     * The endpoint to call, i.e. /helix or a custom (potentially unsupported) endpoint.
+     */
+    type?: TwitchApiCallType;
+    /**
+     * The HTTP method to use. Defaults to `'GET'`.
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * The query parameters to send with the API call.
+     */
+    query?: Record<string, string | string[] | undefined>;
+    /**
+     * The JSON body to send with the API call.
+     *
+     * If `body` is also given, this will be ignored.
+     */
+    jsonBody?: unknown;
+    /**
+     * The list of scopes that can be used by the request.
+     */
+    scopes?: string[];
+    /**
+     * Whether OAuth credentials should be generated and sent with the request. Defaults to `true`.
+     */
+    auth?: boolean;
+}
+/**
+ * An interface to merge compatible fetch options into.
+ *
+ * :::warning
+ *
+ * You should make sure that this does not include the properties `headers`, `method` or `body`
+ * in order to not conflict with the internally used properties.
+ *
+ * :::
+ *
+ * To make use of the web fetch options, merge them into this like so
+ * (assuming that RequestInit is the global type from the dom lib):
+ *
+ * ```ts
+ * declare module '@twurple/api-call' {
+ *     export interface TwitchApiCallFetchOptions extends Omit<RequestInit, 'headers' | 'method' | 'body'> {}
+ * }
+ * ```
+ *
+ * To make use of the node-fetch options, merge them into this like so:
+ *
+ * ```ts
+ * import type { RequestInit as NodeRequestInit } from 'node-fetch';
+ *
+ * declare module '@twurple/api-call' {
+ *     export interface TwitchApiCallFetchOptions extends Omit<NodeRequestInit, 'headers' | 'method' | 'body'> {}
+ * }
+ * ```
+ */
+export interface TwitchApiCallFetchOptions {
+    /** @private */ _dummy?: never;
+}
+//# sourceMappingURL=TwitchApiCallOptions.d.ts.map

package/node_modules/@twurple/api-call/lib/TwitchApiCallOptions.js

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

package/node_modules/@twurple/api-call/lib/apiCall.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { TwitchApiCallFetchOptions, TwitchApiCallOptions } from './TwitchApiCallOptions.js';
+/**
+ * Makes a call to the Twitch API using the given credentials, returning the raw Response object.
+ *
+ * @param options The configuration of the call.
+ * @param clientId The client ID of your application.
+ * @param accessToken The access token to call the API with.
+ *
+ * You need to obtain one using one of the [Twitch OAuth flows](https://dev.twitch.tv/docs/authentication/getting-tokens-oauth/).
+ * @param authorizationType The type of Authorization header to send.
+ *
+ * Defaults to "Bearer" for Helix and "OAuth" for everything else.
+ * @param fetchOptions Additional options to be passed to the `fetch` function.
+ */
+export declare function callTwitchApiRaw(options: TwitchApiCallOptions, clientId?: string, accessToken?: string, authorizationType?: string, fetchOptions?: TwitchApiCallFetchOptions): Promise<Response>;
+/**
+ * Makes a call to the Twitch API using given credentials.
+ *
+ * @param options The configuration of the call.
+ * @param clientId The client ID of your application.
+ * @param accessToken The access token to call the API with.
+ *
+ * You need to obtain one using one of the [Twitch OAuth flows](https://dev.twitch.tv/docs/authentication/getting-tokens-oauth/).
+ * @param authorizationType The type of Authorization header to send.
+ *
+ * Defaults to "Bearer" for Helix and "OAuth" for everything else.
+ * @param fetchOptions Additional options to be passed to the `fetch` function.
+ */
+export declare function callTwitchApi<T = unknown>(options: TwitchApiCallOptions, clientId?: string, accessToken?: string, authorizationType?: string, fetchOptions?: TwitchApiCallFetchOptions): Promise<T>;
+//# sourceMappingURL=apiCall.d.ts.map

package/node_modules/@twurple/api-call/lib/apiCall.js

@@ -0,0 +1,59 @@
+import { qsStringify } from '@twurple/common';
+import { handleTwitchApiResponseError, transformTwitchApiResponse } from './helpers/transform.js';
+import { getTwitchApiUrl } from './helpers/url.js';
+/**
+ * Makes a call to the Twitch API using the given credentials, returning the raw Response object.
+ *
+ * @param options The configuration of the call.
+ * @param clientId The client ID of your application.
+ * @param accessToken The access token to call the API with.
+ *
+ * You need to obtain one using one of the [Twitch OAuth flows](https://dev.twitch.tv/docs/authentication/getting-tokens-oauth/).
+ * @param authorizationType The type of Authorization header to send.
+ *
+ * Defaults to "Bearer" for Helix and "OAuth" for everything else.
+ * @param fetchOptions Additional options to be passed to the `fetch` function.
+ */
+export async function callTwitchApiRaw(options, clientId, accessToken, authorizationType, fetchOptions = {}) {
+    const type = options.type ?? 'helix';
+    const url = getTwitchApiUrl(options.url, type);
+    const params = qsStringify(options.query);
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const headers = new Headers({ Accept: 'application/json' });
+    let body = undefined;
+    if (options.jsonBody) {
+        body = JSON.stringify(options.jsonBody);
+        headers.append('Content-Type', 'application/json');
+    }
+    if (clientId && type !== 'auth') {
+        headers.append('Client-ID', clientId);
+    }
+    if (accessToken) {
+        headers.append('Authorization', `${type === 'helix' ? authorizationType ?? 'Bearer' : 'OAuth'} ${accessToken}`);
+    }
+    const requestOptions = {
+        ...fetchOptions,
+        method: options.method ?? 'GET',
+        headers,
+        body,
+    };
+    return await fetch(`${url}${params}`, requestOptions);
+}
+/**
+ * Makes a call to the Twitch API using given credentials.
+ *
+ * @param options The configuration of the call.
+ * @param clientId The client ID of your application.
+ * @param accessToken The access token to call the API with.
+ *
+ * You need to obtain one using one of the [Twitch OAuth flows](https://dev.twitch.tv/docs/authentication/getting-tokens-oauth/).
+ * @param authorizationType The type of Authorization header to send.
+ *
+ * Defaults to "Bearer" for Helix and "OAuth" for everything else.
+ * @param fetchOptions Additional options to be passed to the `fetch` function.
+ */
+export async function callTwitchApi(options, clientId, accessToken, authorizationType, fetchOptions = {}) {
+    const response = await callTwitchApiRaw(options, clientId, accessToken, authorizationType, fetchOptions);
+    await handleTwitchApiResponseError(response, options);
+    return await transformTwitchApiResponse(response);
+}

package/node_modules/@twurple/api-call/lib/errors/HttpStatusCodeError.d.ts

@@ -0,0 +1,29 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a HTTP error occurs. Some HTTP errors are handled in the library when they're expected.
+ */
+export declare class HttpStatusCodeError extends CustomError {
+    private readonly _statusCode;
+    private readonly _url;
+    private readonly _method;
+    private readonly _body;
+    /** @private */
+    constructor(_statusCode: number, statusText: string, _url: string, _method: string, _body: string, isJson: boolean);
+    /**
+     * The HTTP status code of the error.
+     */
+    get statusCode(): number;
+    /**
+     * The URL that was requested.
+     */
+    get url(): string;
+    /**
+     * The HTTP method that was used for the request.
+     */
+    get method(): string;
+    /**
+     * The body that was used for the request, as a string.
+     */
+    get body(): string;
+}
+//# sourceMappingURL=HttpStatusCodeError.d.ts.map

package/node_modules/@twurple/api-call/lib/errors/HttpStatusCodeError.js

@@ -0,0 +1,42 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a HTTP error occurs. Some HTTP errors are handled in the library when they're expected.
+ */
+export class HttpStatusCodeError extends CustomError {
+    _statusCode;
+    _url;
+    _method;
+    _body;
+    /** @private */
+    constructor(_statusCode, statusText, _url, _method, _body, isJson) {
+        super(`Encountered HTTP status code ${_statusCode}: ${statusText}\n\nURL: ${_url}\nMethod: ${_method}\nBody:\n${!isJson && _body.length > 150 ? `${_body.slice(0, 147)}...` : _body}`);
+        this._statusCode = _statusCode;
+        this._url = _url;
+        this._method = _method;
+        this._body = _body;
+    }
+    /**
+     * The HTTP status code of the error.
+     */
+    get statusCode() {
+        return this._statusCode;
+    }
+    /**
+     * The URL that was requested.
+     */
+    get url() {
+        return this._url;
+    }
+    /**
+     * The HTTP method that was used for the request.
+     */
+    get method() {
+        return this._method;
+    }
+    /**
+     * The body that was used for the request, as a string.
+     */
+    get body() {
+        return this._body;
+    }
+}

package/node_modules/@twurple/api-call/lib/helpers/queries.external.d.ts

@@ -0,0 +1,3 @@
+import { type UserIdResolvable } from '@twurple/common';
+export declare function createBroadcasterQuery(user: UserIdResolvable): Record<string, string>;
+//# sourceMappingURL=queries.external.d.ts.map

package/node_modules/@twurple/api-call/lib/helpers/queries.external.js

@@ -0,0 +1,6 @@
+import { extractUserId } from '@twurple/common';
+export function createBroadcasterQuery(user) {
+    return {
+        broadcaster_id: extractUserId(user),
+    };
+}

package/node_modules/@twurple/api-call/lib/helpers/transform.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { TwitchApiCallOptions } from '../TwitchApiCallOptions.js';
+/** @private */
+export declare function handleTwitchApiResponseError(response: Response, options: TwitchApiCallOptions): Promise<void>;
+/** @private */
+export declare function transformTwitchApiResponse<T>(response: Response): Promise<T>;
+//# sourceMappingURL=transform.d.ts.map

package/node_modules/@twurple/api-call/lib/helpers/transform.js

@@ -0,0 +1,23 @@
+import { qsStringify } from '@twurple/common';
+import { HttpStatusCodeError } from '../errors/HttpStatusCodeError.js';
+/** @private */
+export async function handleTwitchApiResponseError(response, options) {
+    if (!response.ok) {
+        const isJson = response.headers.get('Content-Type') === 'application/json';
+        const text = isJson ? JSON.stringify(await response.json(), null, 2) : await response.text();
+        const params = qsStringify(options.query);
+        const fullUrl = `${options.url}${params}`;
+        throw new HttpStatusCodeError(response.status, response.statusText, fullUrl, options.method ?? 'GET', text, isJson);
+    }
+}
+/** @private */
+export async function transformTwitchApiResponse(response) {
+    if (response.status === 204) {
+        return undefined; // oof
+    }
+    const text = await response.text();
+    if (!text) {
+        return undefined; // mega oof - Twitch doesn't return a response when it should
+    }
+    return JSON.parse(text);
+}

package/node_modules/@twurple/api-call/lib/helpers/url.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=url.d.ts.map