soundcloud-api-ts 1.5.0 → 1.6.0

package/dist/chunk-LNMDNQSC.js

@@ -0,0 +1,1742 @@
+'use strict';
+
+var chunkNBKG62HR_js = require('./chunk-NBKG62HR.js');
+
+// src/client/http.ts
+var BASE_URL = "https://api.soundcloud.com";
+var DEFAULT_RETRY = { maxRetries: 3, retryBaseDelay: 1e3 };
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(status) {
+  return status === 429 || status >= 500 && status <= 599;
+}
+function getRetryDelay(response, attempt, config) {
+  if (response.status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (!Number.isNaN(seconds)) return seconds * 1e3;
+    }
+  }
+  const base = config.retryBaseDelay * Math.pow(2, attempt);
+  return base + Math.random() * base * 0.1;
+}
+async function parseErrorBody(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+async function scFetch(options, refreshCtx) {
+  const retryConfig = refreshCtx?.retry ?? DEFAULT_RETRY;
+  const execute = async (tokenOverride) => {
+    const url = `${BASE_URL}${options.path}`;
+    const headers = {
+      Accept: "application/json"
+    };
+    const token = tokenOverride ?? options.token;
+    if (token) {
+      headers["Authorization"] = `OAuth ${token}`;
+    }
+    let fetchBody;
+    if (options.body) {
+      if (options.body instanceof URLSearchParams) {
+        fetchBody = options.body;
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+      } else if (options.body instanceof FormData) {
+        fetchBody = options.body;
+      } else {
+        headers["Content-Type"] = options.contentType ?? "application/json";
+        fetchBody = JSON.stringify(options.body);
+      }
+    } else if (options.contentType) {
+      headers["Content-Type"] = options.contentType;
+    }
+    let lastResponse;
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: fetchBody,
+        redirect: "manual"
+      });
+      if (response.status === 302) {
+        const location = response.headers.get("location");
+        if (location) return location;
+      }
+      if (response.status === 204 || response.headers.get("content-length") === "0") {
+        return void 0;
+      }
+      if (response.ok) {
+        return response.json();
+      }
+      if (!isRetryable(response.status)) {
+        const body2 = await parseErrorBody(response);
+        throw new chunkNBKG62HR_js.SoundCloudError(response.status, response.statusText, body2);
+      }
+      lastResponse = response;
+      if (attempt < retryConfig.maxRetries) {
+        const delayMs = getRetryDelay(response, attempt, retryConfig);
+        retryConfig.onDebug?.(
+          `Retry ${attempt + 1}/${retryConfig.maxRetries} after ${Math.round(delayMs)}ms (status ${response.status})`
+        );
+        await delay(delayMs);
+      }
+    }
+    const body = await parseErrorBody(lastResponse);
+    throw new chunkNBKG62HR_js.SoundCloudError(lastResponse.status, lastResponse.statusText, body);
+  };
+  try {
+    return await execute();
+  } catch (err) {
+    if (refreshCtx?.onTokenRefresh && err instanceof chunkNBKG62HR_js.SoundCloudError && err.status === 401) {
+      const newToken = await refreshCtx.onTokenRefresh();
+      refreshCtx.setToken(newToken.access_token, newToken.refresh_token);
+      return execute(newToken.access_token);
+    }
+    throw err;
+  }
+}
+async function scFetchUrl(url, token, retryConfig) {
+  const config = retryConfig ?? DEFAULT_RETRY;
+  const headers = { Accept: "application/json" };
+  if (token) headers["Authorization"] = `OAuth ${token}`;
+  let lastResponse;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    const response = await fetch(url, { method: "GET", headers, redirect: "manual" });
+    if (response.status === 302) {
+      const location = response.headers.get("location");
+      if (location) return location;
+    }
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return void 0;
+    }
+    if (response.ok) {
+      return response.json();
+    }
+    if (!isRetryable(response.status)) {
+      const body2 = await parseErrorBody(response);
+      throw new chunkNBKG62HR_js.SoundCloudError(response.status, response.statusText, body2);
+    }
+    lastResponse = response;
+    if (attempt < config.maxRetries) {
+      const delayMs = getRetryDelay(response, attempt, config);
+      config.onDebug?.(
+        `Retry ${attempt + 1}/${config.maxRetries} after ${Math.round(delayMs)}ms (status ${response.status})`
+      );
+      await delay(delayMs);
+    }
+  }
+  const body = await parseErrorBody(lastResponse);
+  throw new chunkNBKG62HR_js.SoundCloudError(lastResponse.status, lastResponse.statusText, body);
+}
+
+// src/client/paginate.ts
+async function* paginate(firstPage, fetchNext) {
+  let page = await firstPage();
+  yield page.collection;
+  while (page.next_href) {
+    page = await fetchNext(page.next_href);
+    yield page.collection;
+  }
+}
+async function* paginateItems(firstPage, fetchNext) {
+  for await (const page of paginate(firstPage, fetchNext)) {
+    for (const item of page) {
+      yield item;
+    }
+  }
+}
+async function fetchAll(firstPage, fetchNext, options) {
+  const result = [];
+  const max = options?.maxItems ?? Infinity;
+  for await (const page of paginate(firstPage, fetchNext)) {
+    for (const item of page) {
+      result.push(item);
+      if (result.length >= max) return result;
+    }
+  }
+  return result;
+}
+
+// src/client/SoundCloudClient.ts
+function resolveToken(tokenGetter, explicit) {
+  const t = explicit ?? tokenGetter();
+  if (!t) throw new Error("No access token available. Call client.setToken() or pass a token explicitly.");
+  return t;
+}
+exports.SoundCloudClient = class _SoundCloudClient {
+  config;
+  _accessToken;
+  _refreshToken;
+  /** Authentication methods (OAuth token grants, sign out) */
+  auth;
+  /** Authenticated user endpoints (/me) */
+  me;
+  /** User profile endpoints (/users) */
+  users;
+  /** Track endpoints (/tracks) */
+  tracks;
+  /** Playlist endpoints (/playlists) */
+  playlists;
+  /** Search endpoints */
+  search;
+  /** URL resolution endpoint (/resolve) */
+  resolve;
+  /** Like/unlike actions (/likes) */
+  likes;
+  /** Repost/unrepost actions (/reposts) */
+  reposts;
+  /**
+   * Creates a new SoundCloudClient instance.
+   *
+   * @param config - Client configuration including OAuth credentials and optional settings
+   */
+  constructor(config) {
+    this.config = config;
+    const getToken = () => this._accessToken;
+    const retryConfig = {
+      maxRetries: config.maxRetries ?? 3,
+      retryBaseDelay: config.retryBaseDelay ?? 1e3,
+      onDebug: config.onDebug
+    };
+    const refreshCtx = config.onTokenRefresh ? {
+      getToken,
+      onTokenRefresh: async () => {
+        const result = await config.onTokenRefresh(this);
+        return result;
+      },
+      setToken: (a, r) => this.setToken(a, r),
+      retry: retryConfig
+    } : {
+      getToken,
+      setToken: (a, r) => this.setToken(a, r),
+      retry: retryConfig
+    };
+    this.auth = new _SoundCloudClient.Auth(this.config);
+    this.me = new _SoundCloudClient.Me(getToken, refreshCtx);
+    this.users = new _SoundCloudClient.Users(getToken, refreshCtx);
+    this.tracks = new _SoundCloudClient.Tracks(getToken, refreshCtx);
+    this.playlists = new _SoundCloudClient.Playlists(getToken, refreshCtx);
+    this.search = new _SoundCloudClient.Search(getToken, refreshCtx);
+    this.resolve = new _SoundCloudClient.Resolve(getToken, refreshCtx);
+    this.likes = new _SoundCloudClient.Likes(getToken, refreshCtx);
+    this.reposts = new _SoundCloudClient.Reposts(getToken, refreshCtx);
+  }
+  /**
+   * Store an access token (and optionally refresh token) on this client instance.
+   *
+   * @param accessToken - The OAuth access token to store
+   * @param refreshToken - Optional refresh token for automatic token renewal
+   */
+  setToken(accessToken, refreshToken) {
+    this._accessToken = accessToken;
+    if (refreshToken !== void 0) this._refreshToken = refreshToken;
+  }
+  /** Clear all stored tokens from this client instance. */
+  clearToken() {
+    this._accessToken = void 0;
+    this._refreshToken = void 0;
+  }
+  /** Get the currently stored access token, or `undefined` if none is set. */
+  get accessToken() {
+    return this._accessToken;
+  }
+  /** Get the currently stored refresh token, or `undefined` if none is set. */
+  get refreshToken() {
+    return this._refreshToken;
+  }
+  /**
+   * Async generator that follows `next_href` automatically, yielding each page's `collection`.
+   *
+   * @param firstPage - Function that fetches the first page
+   * @returns An async generator yielding arrays of items (one per page)
+   *
+   * @example
+   * ```ts
+   * for await (const page of sc.paginate(() => sc.search.tracks('lofi'))) {
+   *   console.log(page); // SoundCloudTrack[]
+   * }
+   * ```
+   */
+  paginate(firstPage) {
+    const token = this._accessToken;
+    return paginate(firstPage, (url) => scFetchUrl(url, token));
+  }
+  /**
+   * Async generator that yields individual items across all pages.
+   *
+   * @param firstPage - Function that fetches the first page
+   * @returns An async generator yielding individual items
+   *
+   * @example
+   * ```ts
+   * for await (const track of sc.paginateItems(() => sc.search.tracks('lofi'))) {
+   *   console.log(track.title); // single SoundCloudTrack
+   * }
+   * ```
+   */
+  paginateItems(firstPage) {
+    const token = this._accessToken;
+    return paginateItems(firstPage, (url) => scFetchUrl(url, token));
+  }
+  /**
+   * Collects all pages into a single flat array.
+   *
+   * @param firstPage - Function that fetches the first page
+   * @param options - Optional configuration
+   * @param options.maxItems - Maximum number of items to collect
+   * @returns A promise resolving to a flat array of all items
+   *
+   * @example
+   * ```ts
+   * const allTracks = await sc.fetchAll(() => sc.search.tracks('lofi'), { maxItems: 100 });
+   * console.log(allTracks.length);
+   * ```
+   */
+  fetchAll(firstPage, options) {
+    const token = this._accessToken;
+    return fetchAll(firstPage, (url) => scFetchUrl(url, token), options);
+  }
+};
+((SoundCloudClient2) => {
+  class Auth {
+    constructor(config) {
+      this.config = config;
+    }
+    /**
+     * Build the authorization URL to redirect users to SoundCloud's OAuth login page.
+     *
+     * @param options - Optional parameters for the authorization request
+     * @param options.state - Opaque state value for CSRF protection
+     * @param options.codeChallenge - PKCE S256 code challenge for enhanced security
+     * @returns The full authorization URL to redirect the user to
+     * @throws {Error} If `redirectUri` was not provided in the client config
+     *
+     * @example
+     * ```ts
+     * const url = sc.auth.getAuthorizationUrl({ state: 'random-state' });
+     * // Redirect user to `url`
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/oauth2
+     */
+    getAuthorizationUrl(options) {
+      if (!this.config.redirectUri) throw new Error("redirectUri is required for getAuthorizationUrl");
+      const params = new URLSearchParams({
+        client_id: this.config.clientId,
+        redirect_uri: this.config.redirectUri,
+        response_type: "code"
+      });
+      if (options?.state) params.set("state", options.state);
+      if (options?.codeChallenge) {
+        params.set("code_challenge", options.codeChallenge);
+        params.set("code_challenge_method", "S256");
+      }
+      return `https://api.soundcloud.com/connect?${params}`;
+    }
+    /**
+     * Exchange client credentials for an access token (machine-to-machine auth).
+     *
+     * @returns The OAuth token response
+     * @throws {SoundCloudError} When authentication fails
+     *
+     * @example
+     * ```ts
+     * const token = await sc.auth.getClientToken();
+     * sc.setToken(token.access_token);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/oauth2/post_oauth2_token
+     */
+    async getClientToken() {
+      return scFetch({
+        path: "/oauth2/token",
+        method: "POST",
+        body: new URLSearchParams({
+          grant_type: "client_credentials",
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret
+        })
+      });
+    }
+    /**
+     * Exchange an authorization code for user tokens (authorization_code grant).
+     *
+     * @param code - The authorization code received from the OAuth callback
+     * @param codeVerifier - PKCE code verifier if a code challenge was used
+     * @returns The OAuth token response including access and refresh tokens
+     * @throws {SoundCloudError} When the code is invalid or expired
+     *
+     * @example
+     * ```ts
+     * const token = await sc.auth.getUserToken(code, codeVerifier);
+     * sc.setToken(token.access_token, token.refresh_token);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/oauth2/post_oauth2_token
+     */
+    async getUserToken(code, codeVerifier) {
+      const params = {
+        grant_type: "authorization_code",
+        client_id: this.config.clientId,
+        client_secret: this.config.clientSecret,
+        redirect_uri: this.config.redirectUri,
+        code
+      };
+      if (codeVerifier) params.code_verifier = codeVerifier;
+      return scFetch({
+        path: "/oauth2/token",
+        method: "POST",
+        body: new URLSearchParams(params)
+      });
+    }
+    /**
+     * Refresh an expired access token using a refresh token.
+     *
+     * @param refreshToken - The refresh token from a previous token response
+     * @returns A new OAuth token response with fresh access and refresh tokens
+     * @throws {SoundCloudError} When the refresh token is invalid or expired
+     *
+     * @example
+     * ```ts
+     * const newToken = await sc.auth.refreshUserToken(sc.refreshToken!);
+     * sc.setToken(newToken.access_token, newToken.refresh_token);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/oauth2/post_oauth2_token
+     */
+    async refreshUserToken(refreshToken) {
+      return scFetch({
+        path: "/oauth2/token",
+        method: "POST",
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret,
+          redirect_uri: this.config.redirectUri,
+          refresh_token: refreshToken
+        })
+      });
+    }
+    /**
+     * Invalidate the session associated with an access token.
+     *
+     * **Note:** This hits `https://secure.soundcloud.com`, NOT the regular
+     * `api.soundcloud.com` host used by all other endpoints.
+     *
+     * @param accessToken - The access token to invalidate
+     * @throws {Error} When the sign-out request fails
+     *
+     * @example
+     * ```ts
+     * await sc.auth.signOut(sc.accessToken!);
+     * sc.clearToken();
+     * ```
+     */
+    async signOut(accessToken) {
+      const res = await fetch("https://secure.soundcloud.com/sign-out", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: accessToken })
+      });
+      if (!res.ok) throw new Error(`Sign-out failed: ${res.status}`);
+    }
+  }
+  SoundCloudClient2.Auth = Auth;
+  class Me {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Get the authenticated user's profile.
+     *
+     * @param options - Optional token override
+     * @returns The authenticated user's full profile
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const me = await sc.me.getMe();
+     * console.log(me.username, me.followers_count);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me
+     */
+    async getMe(options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: "/me", method: "GET", token: t });
+    }
+    /**
+     * Get the authenticated user's activity feed.
+     *
+     * @param limit - Maximum number of activities per page
+     * @param options - Optional token override
+     * @returns Paginated activities response with `future_href` for polling
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const activities = await sc.me.getActivities(25);
+     * activities.collection.forEach(a => console.log(a.type, a.created_at));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_activities
+     */
+    async getActivities(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/activities?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get the authenticated user's own activities (uploads, reposts).
+     *
+     * @param limit - Maximum number of activities per page
+     * @param options - Optional token override
+     * @returns Paginated activities response
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_activities_all_own
+     */
+    async getActivitiesOwn(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/activities/all/own?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get track-related activities in the authenticated user's feed.
+     *
+     * @param limit - Maximum number of activities per page
+     * @param options - Optional token override
+     * @returns Paginated activities response filtered to track activities
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_activities_tracks
+     */
+    async getActivitiesTracks(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/activities/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get tracks liked by the authenticated user.
+     *
+     * @param limit - Maximum number of tracks per page
+     * @param options - Optional token override
+     * @returns Paginated list of liked tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const likes = await sc.me.getLikesTracks(50);
+     * likes.collection.forEach(t => console.log(t.title));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_likes_tracks
+     */
+    async getLikesTracks(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/likes/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get playlists liked by the authenticated user.
+     *
+     * @param limit - Maximum number of playlists per page
+     * @param options - Optional token override
+     * @returns Paginated list of liked playlists
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_likes_playlists
+     */
+    async getLikesPlaylists(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/likes/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get users the authenticated user is following.
+     *
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of followed users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_followings
+     */
+    async getFollowings(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get recent tracks from users the authenticated user is following.
+     *
+     * @param limit - Maximum number of tracks per page
+     * @param options - Optional token override
+     * @returns Paginated list of tracks from followed users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_followings_tracks
+     */
+    async getFollowingsTracks(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Follow a user.
+     *
+     * @param userUrn - The user's ID or URN to follow
+     * @param options - Optional token override
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * await sc.me.follow(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/put_me_followings__user_id_
+     */
+    async follow(userUrn, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings/${userUrn}`, method: "PUT", token: t });
+    }
+    /**
+     * Unfollow a user.
+     *
+     * @param userUrn - The user's ID or URN to unfollow
+     * @param options - Optional token override
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * await sc.me.unfollow(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/delete_me_followings__user_id_
+     */
+    async unfollow(userUrn, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings/${userUrn}`, method: "DELETE", token: t });
+    }
+    /**
+     * Get the authenticated user's followers.
+     *
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of follower users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_followers
+     */
+    async getFollowers(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followers?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get the authenticated user's playlists.
+     *
+     * @param limit - Maximum number of playlists per page
+     * @param options - Optional token override
+     * @returns Paginated list of playlists
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_playlists
+     */
+    async getPlaylists(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get the authenticated user's tracks.
+     *
+     * @param limit - Maximum number of tracks per page
+     * @param options - Optional token override
+     * @returns Paginated list of tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/me/get_me_tracks
+     */
+    async getTracks(limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+  }
+  SoundCloudClient2.Me = Me;
+  class Users {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Get a user's profile by ID.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param options - Optional token override
+     * @returns The user's public profile
+     * @throws {SoundCloudError} When the user is not found or the API returns an error
+     *
+     * @example
+     * ```ts
+     * const user = await sc.users.getUser(123456);
+     * console.log(user.username, user.followers_count);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id_
+     */
+    async getUser(userId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}`, method: "GET", token: t });
+    }
+    /**
+     * Get a user's followers.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of followers per page
+     * @param options - Optional token override
+     * @returns Paginated list of follower users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__followers
+     */
+    async getFollowers(userId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/followers?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get users that a user is following.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of followed users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__followings
+     */
+    async getFollowings(userId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/followings?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get a user's public tracks.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of tracks per page
+     * @param options - Optional token override
+     * @returns Paginated list of tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__tracks
+     */
+    async getTracks(userId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get a user's public playlists.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of playlists per page
+     * @param options - Optional token override
+     * @returns Paginated list of playlists (without full track data)
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__playlists
+     */
+    async getPlaylists(userId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true&show_tracks=false`, method: "GET", token: t });
+    }
+    /**
+     * Get tracks liked by a user.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of tracks per page
+     * @param cursor - Pagination cursor from a previous response's `next_href`
+     * @param options - Optional token override
+     * @returns Paginated list of liked tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__likes_tracks
+     */
+    async getLikesTracks(userId, limit, cursor, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/likes/tracks?${limit ? `limit=${limit}&` : ""}${cursor ? `cursor=${cursor}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get playlists liked by a user.
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param limit - Maximum number of playlists per page
+     * @param options - Optional token override
+     * @returns Paginated list of liked playlists
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__likes_playlists
+     */
+    async getLikesPlaylists(userId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/likes/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get a user's external web profile links (Twitter, Instagram, etc.).
+     *
+     * @param userId - The user's numeric ID or URN
+     * @param options - Optional token override
+     * @returns Array of web profile objects
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const profiles = await sc.users.getWebProfiles(123456);
+     * profiles.forEach(p => console.log(p.service, p.url));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users__user_id__web_profiles
+     */
+    async getWebProfiles(userId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}/web-profiles`, method: "GET", token: t });
+    }
+  }
+  SoundCloudClient2.Users = Users;
+  class Tracks {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Get a track by ID.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns The track object with full metadata
+     * @throws {SoundCloudError} When the track is not found or the API returns an error
+     *
+     * @example
+     * ```ts
+     * const track = await sc.tracks.getTrack(123456);
+     * console.log(track.title, track.duration);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id_
+     */
+    async getTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}`, method: "GET", token: t });
+    }
+    /**
+     * Get stream URLs for a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns Object containing available stream URLs (HLS, MP3, preview)
+     * @throws {SoundCloudError} When the track is not found or not streamable
+     *
+     * @example
+     * ```ts
+     * const streams = await sc.tracks.getStreams(123456);
+     * console.log(streams.hls_mp3_128_url);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id__streams
+     */
+    async getStreams(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}/streams`, method: "GET", token: t });
+    }
+    /**
+     * Get comments on a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param limit - Maximum number of comments per page
+     * @param options - Optional token override
+     * @returns Paginated list of comments
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id__comments
+     */
+    async getComments(trackId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}/comments?threaded=1&filter_replies=0${limit ? `&limit=${limit}` : ""}&linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Post a comment on a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param body - The comment text
+     * @param timestamp - Position in the track in milliseconds where the comment is placed
+     * @param options - Optional token override
+     * @returns The created comment object
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const comment = await sc.tracks.createComment(123456, 'Great track!', 30000);
+     * console.log(comment.id);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/post_tracks__track_id__comments
+     */
+    async createComment(trackId, body, timestamp, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({
+        path: `/tracks/${trackId}/comments`,
+        method: "POST",
+        token: t,
+        body: { comment: { body, ...timestamp !== void 0 ? { timestamp } : {} } }
+      });
+    }
+    /**
+     * Get users who have liked (favorited) a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of users who liked the track
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id__favoriters
+     */
+    async getLikes(trackId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}/favoriters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get users who have reposted a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of users who reposted the track
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id__reposters
+     */
+    async getReposts(trackId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}/reposters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Get tracks related to a given track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param limit - Maximum number of related tracks to return
+     * @param options - Optional token override
+     * @returns Array of related tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const related = await sc.tracks.getRelated(123456, 5);
+     * related.forEach(t => console.log(t.title));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks__track_id__related
+     */
+    async getRelated(trackId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}/related${limit ? `?limit=${limit}` : ""}`, method: "GET", token: t });
+    }
+    /**
+     * Update a track's metadata.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param params - Fields to update (title, description, genre, etc.)
+     * @param options - Optional token override
+     * @returns The updated track object
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const updated = await sc.tracks.update(123456, { title: 'New Title', genre: 'Electronic' });
+     * console.log(updated.title);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/put_tracks__track_id_
+     */
+    async update(trackId, params, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}`, method: "PUT", token: t, body: { track: params } });
+    }
+    /**
+     * Delete a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * await sc.tracks.delete(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/delete_tracks__track_id_
+     */
+    async delete(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}`, method: "DELETE", token: t });
+    }
+  }
+  SoundCloudClient2.Tracks = Tracks;
+  class Playlists {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Get a playlist by ID.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @returns The playlist object with track data
+     * @throws {SoundCloudError} When the playlist is not found or the API returns an error
+     *
+     * @example
+     * ```ts
+     * const playlist = await sc.playlists.getPlaylist(123456);
+     * console.log(playlist.title, playlist.track_count);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/get_playlists__playlist_id_
+     */
+    async getPlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}`, method: "GET", token: t });
+    }
+    /**
+     * Get tracks in a playlist.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param limit - Maximum number of tracks per page
+     * @param offset - Number of tracks to skip (for offset-based pagination)
+     * @param options - Optional token override
+     * @returns Paginated list of tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/get_playlists__playlist_id__tracks
+     */
+    async getTracks(playlistId, limit, offset, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true${offset ? `&offset=${offset}` : ""}`, method: "GET", token: t });
+    }
+    /**
+     * Get users who have reposted a playlist.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param limit - Maximum number of users per page
+     * @param options - Optional token override
+     * @returns Paginated list of users who reposted the playlist
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/get_playlists__playlist_id__reposters
+     */
+    async getReposts(playlistId, limit, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}/reposters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token: t });
+    }
+    /**
+     * Create a new playlist.
+     *
+     * @param params - Playlist creation parameters (title is required)
+     * @param options - Optional token override
+     * @returns The created playlist object
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const playlist = await sc.playlists.create({
+     *   title: 'My Favorites',
+     *   sharing: 'public',
+     *   tracks: [{ urn: 'soundcloud:tracks:123' }],
+     * });
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/post_playlists
+     */
+    async create(params, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: "/playlists", method: "POST", token: t, body: { playlist: params } });
+    }
+    /**
+     * Update a playlist's metadata or track list.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param params - Fields to update
+     * @param options - Optional token override
+     * @returns The updated playlist object
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const updated = await sc.playlists.update(123456, { title: 'Updated Title' });
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/put_playlists__playlist_id_
+     */
+    async update(playlistId, params, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}`, method: "PUT", token: t, body: { playlist: params } });
+    }
+    /**
+     * Delete a playlist.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * await sc.playlists.delete(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/delete_playlists__playlist_id_
+     */
+    async delete(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}`, method: "DELETE", token: t });
+    }
+  }
+  SoundCloudClient2.Playlists = Playlists;
+  class Search {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Search for tracks by query string.
+     *
+     * @param query - Search query text
+     * @param pageNumber - Zero-based page number (10 results per page)
+     * @param options - Optional token override
+     * @returns Paginated list of matching tracks
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const results = await sc.search.tracks('lofi hip hop');
+     * results.collection.forEach(t => console.log(t.title));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/tracks/get_tracks
+     */
+    async tracks(query, pageNumber, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token: t });
+    }
+    /**
+     * Search for users by query string.
+     *
+     * @param query - Search query text
+     * @param pageNumber - Zero-based page number (10 results per page)
+     * @param options - Optional token override
+     * @returns Paginated list of matching users
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const results = await sc.search.users('deadmau5');
+     * results.collection.forEach(u => console.log(u.username));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/users/get_users
+     */
+    async users(query, pageNumber, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token: t });
+    }
+    /**
+     * Search for playlists by query string.
+     *
+     * @param query - Search query text
+     * @param pageNumber - Zero-based page number (10 results per page)
+     * @param options - Optional token override
+     * @returns Paginated list of matching playlists
+     * @throws {SoundCloudError} When the API returns an error
+     *
+     * @example
+     * ```ts
+     * const results = await sc.search.playlists('chill vibes');
+     * results.collection.forEach(p => console.log(p.title));
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/playlists/get_playlists
+     */
+    async playlists(query, pageNumber, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token: t });
+    }
+  }
+  SoundCloudClient2.Search = Search;
+  class Resolve {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Resolve a SoundCloud URL to its API resource URL.
+     *
+     * @param url - A SoundCloud URL (e.g. "https://soundcloud.com/artist/track-name")
+     * @param options - Optional token override
+     * @returns The resolved API resource URL (via 302 redirect)
+     * @throws {SoundCloudError} When the URL cannot be resolved
+     *
+     * @example
+     * ```ts
+     * const apiUrl = await sc.resolve.resolveUrl('https://soundcloud.com/deadmau5/strobe');
+     * console.log(apiUrl); // "https://api.soundcloud.com/tracks/..."
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/resolve/get_resolve
+     */
+    async resolveUrl(url, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/resolve?url=${encodeURIComponent(url)}`, method: "GET", token: t });
+    }
+  }
+  SoundCloudClient2.Resolve = Resolve;
+  class Likes {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Like a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the like was successful, `false` on failure
+     *
+     * @example
+     * ```ts
+     * const success = await sc.likes.likeTrack(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/likes/post_likes_tracks__track_id_
+     */
+    async likeTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/likes/tracks/${trackId}`, method: "POST", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Unlike a track.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the unlike was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/likes/delete_likes_tracks__track_id_
+     */
+    async unlikeTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/likes/tracks/${trackId}`, method: "DELETE", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Like a playlist.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the like was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/likes/post_likes_playlists__playlist_id_
+     */
+    async likePlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/likes/playlists/${playlistId}`, method: "POST", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Unlike a playlist.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the unlike was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/likes/delete_likes_playlists__playlist_id_
+     */
+    async unlikePlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/likes/playlists/${playlistId}`, method: "DELETE", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  SoundCloudClient2.Likes = Likes;
+  class Reposts {
+    constructor(getToken, refreshCtx) {
+      this.getToken = getToken;
+      this.refreshCtx = refreshCtx;
+    }
+    fetch(opts) {
+      return scFetch(opts, this.refreshCtx);
+    }
+    /**
+     * Repost a track to your profile.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the repost was successful, `false` on failure
+     *
+     * @example
+     * ```ts
+     * const success = await sc.reposts.repostTrack(123456);
+     * ```
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/reposts/post_reposts_tracks__track_id_
+     */
+    async repostTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/reposts/tracks/${trackId}`, method: "POST", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Remove a track repost from your profile.
+     *
+     * @param trackId - The track's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the unrepost was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/reposts/delete_reposts_tracks__track_id_
+     */
+    async unrepostTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/reposts/tracks/${trackId}`, method: "DELETE", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Repost a playlist to your profile.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the repost was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/reposts/post_reposts_playlists__playlist_id_
+     */
+    async repostPlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/reposts/playlists/${playlistId}`, method: "POST", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Remove a playlist repost from your profile.
+     *
+     * @param playlistId - The playlist's numeric ID or URN
+     * @param options - Optional token override
+     * @returns `true` if the unrepost was successful, `false` on failure
+     *
+     * @see https://developers.soundcloud.com/docs/api/explorer/open-api#/reposts/delete_reposts_playlists__playlist_id_
+     */
+    async unrepostPlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      try {
+        await this.fetch({ path: `/reposts/playlists/${playlistId}`, method: "DELETE", token: t });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  SoundCloudClient2.Reposts = Reposts;
+})(exports.SoundCloudClient || (exports.SoundCloudClient = {}));
+
+// src/auth/getClientToken.ts
+var getClientToken = (clientId, clientSecret) => {
+  return scFetch({
+    path: "/oauth2/token",
+    method: "POST",
+    body: new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: clientId,
+      client_secret: clientSecret
+    })
+  });
+};
+
+// src/auth/getUserToken.ts
+var getUserToken = (clientId, clientSecret, redirectUri, code, codeVerifier) => {
+  const params = {
+    grant_type: "authorization_code",
+    client_id: clientId,
+    client_secret: clientSecret,
+    redirect_uri: redirectUri,
+    code
+  };
+  if (codeVerifier) params.code_verifier = codeVerifier;
+  return scFetch({
+    path: "/oauth2/token",
+    method: "POST",
+    body: new URLSearchParams(params)
+  });
+};
+
+// src/auth/refreshUserToken.ts
+var refreshUserToken = (clientId, clientSecret, redirectUri, refreshToken) => {
+  return scFetch({
+    path: "/oauth2/token",
+    method: "POST",
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: redirectUri,
+      refresh_token: refreshToken
+    })
+  });
+};
+
+// src/auth/signOut.ts
+var signOut = async (accessToken) => {
+  const res = await fetch("https://secure.soundcloud.com/sign-out", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ access_token: accessToken })
+  });
+  if (!res.ok) throw new Error(`Sign-out failed: ${res.status}`);
+};
+
+// src/auth/getAuthorizationUrl.ts
+function getAuthorizationUrl(clientId, redirectUri, options) {
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code"
+  });
+  if (options?.state) params.set("state", options.state);
+  if (options?.codeChallenge) {
+    params.set("code_challenge", options.codeChallenge);
+    params.set("code_challenge_method", "S256");
+  }
+  return `https://api.soundcloud.com/connect?${params}`;
+}
+
+// src/auth/pkce.ts
+function generateCodeVerifier() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return base64url(bytes);
+}
+async function generateCodeChallenge(verifier) {
+  const data = new TextEncoder().encode(verifier);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  return base64url(new Uint8Array(digest));
+}
+function base64url(bytes) {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/users/getMe.ts
+var getMe = (token) => scFetch({ path: "/me", method: "GET", token });
+
+// src/users/getUser.ts
+var getUser = (token, userId) => scFetch({ path: `/users/${userId}`, method: "GET", token });
+
+// src/users/getFollowers.ts
+var getFollowers = (token, userId, limit) => scFetch({ path: `/users/${userId}/followers?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/users/getFollowings.ts
+var getFollowings = (token, userId, limit) => scFetch({ path: `/users/${userId}/followings?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/users/getTracks.ts
+var getUserTracks = (token, userId, limit) => scFetch({ path: `/users/${userId}/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/users/getPlaylists.ts
+var getUserPlaylists = (token, userId, limit) => scFetch({ path: `/users/${userId}/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true&show_tracks=false`, method: "GET", token });
+
+// src/users/getLikesTracks.ts
+var getUserLikesTracks = (token, userId, limit, cursor) => scFetch({ path: `/users/${userId}/likes/tracks?${limit ? `limit=${limit}&` : ""}${cursor ? `cursor=${cursor}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/users/getLikesPlaylists.ts
+var getUserLikesPlaylists = (token, userId, limit) => scFetch({ path: `/users/${userId}/likes/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/users/getWebProfiles.ts
+var getUserWebProfiles = (token, userId) => scFetch({ path: `/users/${userId}/web-profiles`, method: "GET", token });
+
+// src/tracks/getTrack.ts
+var getTrack = (token, trackId) => scFetch({ path: `/tracks/${trackId}`, method: "GET", token });
+
+// src/tracks/getComments.ts
+var getTrackComments = (token, trackId, limit) => scFetch({ path: `/tracks/${trackId}/comments?threaded=1&filter_replies=0${limit ? `&limit=${limit}` : ""}&linked_partitioning=true`, method: "GET", token });
+
+// src/tracks/createComment.ts
+var createTrackComment = (token, trackId, body, timestamp) => scFetch({
+  path: `/tracks/${trackId}/comments`,
+  method: "POST",
+  token,
+  body: { comment: { body, ...timestamp !== void 0 ? { timestamp } : {} } }
+});
+
+// src/tracks/getLikes.ts
+var getTrackLikes = (token, trackId, limit) => scFetch({ path: `/tracks/${trackId}/favoriters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/tracks/getReposts.ts
+var getTrackReposts = (token, trackId, limit) => scFetch({ path: `/tracks/${trackId}/reposters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/tracks/getRelated.ts
+var getRelatedTracks = (token, trackId, limit) => scFetch({ path: `/tracks/${trackId}/related${limit ? `?limit=${limit}` : ""}`, method: "GET", token });
+
+// src/tracks/getStreams.ts
+var getTrackStreams = (token, trackId) => scFetch({ path: `/tracks/${trackId}/streams`, method: "GET", token });
+
+// src/tracks/likeTrack.ts
+var likeTrack = async (token, trackId) => {
+  try {
+    await scFetch({ path: `/likes/tracks/${trackId}`, method: "POST", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/tracks/unlikeTrack.ts
+var unlikeTrack = async (token, trackId) => {
+  try {
+    await scFetch({ path: `/likes/tracks/${trackId}`, method: "DELETE", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/tracks/updateTrack.ts
+var updateTrack = (token, trackId, params) => scFetch({
+  path: `/tracks/${trackId}`,
+  method: "PUT",
+  token,
+  body: { track: params }
+});
+
+// src/tracks/deleteTrack.ts
+var deleteTrack = (token, trackId) => scFetch({ path: `/tracks/${trackId}`, method: "DELETE", token });
+
+// src/playlists/getPlaylist.ts
+var getPlaylist = (token, playlistId) => scFetch({ path: `/playlists/${playlistId}`, method: "GET", token });
+
+// src/playlists/getTracks.ts
+var getPlaylistTracks = (token, playlistId, limit, offset) => scFetch({ path: `/playlists/${playlistId}/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true${offset ? `&offset=${offset}` : ""}`, method: "GET", token });
+
+// src/playlists/getReposts.ts
+var getPlaylistReposts = (token, playlistId, limit) => scFetch({ path: `/playlists/${playlistId}/reposters?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/playlists/createPlaylist.ts
+var createPlaylist = (token, params) => scFetch({
+  path: "/playlists",
+  method: "POST",
+  token,
+  body: { playlist: params }
+});
+
+// src/playlists/updatePlaylist.ts
+var updatePlaylist = (token, playlistId, params) => scFetch({
+  path: `/playlists/${playlistId}`,
+  method: "PUT",
+  token,
+  body: { playlist: params }
+});
+
+// src/playlists/deletePlaylist.ts
+var deletePlaylist = (token, playlistId) => scFetch({ path: `/playlists/${playlistId}`, method: "DELETE", token });
+
+// src/search/searchTracks.ts
+var searchTracks = (token, query, pageNumber) => scFetch({ path: `/tracks?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token });
+
+// src/search/searchUsers.ts
+var searchUsers = (token, query, pageNumber) => scFetch({ path: `/users?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token });
+
+// src/search/searchPlaylists.ts
+var searchPlaylists = (token, query, pageNumber) => scFetch({ path: `/playlists?q=${encodeURIComponent(query)}&linked_partitioning=true&limit=10${pageNumber && pageNumber > 0 ? `&offset=${10 * pageNumber}` : ""}`, method: "GET", token });
+
+// src/resolve/resolveUrl.ts
+var resolveUrl = (token, url) => scFetch({ path: `/resolve?url=${encodeURIComponent(url)}`, method: "GET", token });
+
+// src/me/activities.ts
+var getMeActivities = (token, limit) => scFetch({ path: `/me/activities?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+var getMeActivitiesOwn = (token, limit) => scFetch({ path: `/me/activities/all/own?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+var getMeActivitiesTracks = (token, limit) => scFetch({ path: `/me/activities/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/me/likes.ts
+var getMeLikesTracks = (token, limit) => scFetch({ path: `/me/likes/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+var getMeLikesPlaylists = (token, limit) => scFetch({ path: `/me/likes/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/me/followings.ts
+var getMeFollowings = (token, limit) => scFetch({ path: `/me/followings?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+var getMeFollowingsTracks = (token, limit) => scFetch({ path: `/me/followings/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+var followUser = (token, userUrn) => scFetch({ path: `/me/followings/${userUrn}`, method: "PUT", token });
+var unfollowUser = (token, userUrn) => scFetch({ path: `/me/followings/${userUrn}`, method: "DELETE", token });
+
+// src/me/followers.ts
+var getMeFollowers = (token, limit) => scFetch({ path: `/me/followers?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/me/playlists.ts
+var getMePlaylists = (token, limit) => scFetch({ path: `/me/playlists?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/me/tracks.ts
+var getMeTracks = (token, limit) => scFetch({ path: `/me/tracks?${limit ? `limit=${limit}&` : ""}linked_partitioning=true`, method: "GET", token });
+
+// src/likes/index.ts
+var likePlaylist = async (token, playlistId) => {
+  try {
+    await scFetch({ path: `/likes/playlists/${playlistId}`, method: "POST", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var unlikePlaylist = async (token, playlistId) => {
+  try {
+    await scFetch({ path: `/likes/playlists/${playlistId}`, method: "DELETE", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/reposts/index.ts
+var repostTrack = async (token, trackId) => {
+  try {
+    await scFetch({ path: `/reposts/tracks/${trackId}`, method: "POST", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var unrepostTrack = async (token, trackId) => {
+  try {
+    await scFetch({ path: `/reposts/tracks/${trackId}`, method: "DELETE", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var repostPlaylist = async (token, playlistId) => {
+  try {
+    await scFetch({ path: `/reposts/playlists/${playlistId}`, method: "POST", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var unrepostPlaylist = async (token, playlistId) => {
+  try {
+    await scFetch({ path: `/reposts/playlists/${playlistId}`, method: "DELETE", token });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/utils/widget.ts
+var getSoundCloudWidgetUrl = (trackId) => `https%3A//api.soundcloud.com/tracks/${trackId}&show_teaser=false&color=%2300a99d&inverse=false&show_user=false&sharing=false&buying=false&liking=false&show_artwork=false&show_name=false`;
+
+exports.createPlaylist = createPlaylist;
+exports.createTrackComment = createTrackComment;
+exports.deletePlaylist = deletePlaylist;
+exports.deleteTrack = deleteTrack;
+exports.fetchAll = fetchAll;
+exports.followUser = followUser;
+exports.generateCodeChallenge = generateCodeChallenge;
+exports.generateCodeVerifier = generateCodeVerifier;
+exports.getAuthorizationUrl = getAuthorizationUrl;
+exports.getClientToken = getClientToken;
+exports.getFollowers = getFollowers;
+exports.getFollowings = getFollowings;
+exports.getMe = getMe;
+exports.getMeActivities = getMeActivities;
+exports.getMeActivitiesOwn = getMeActivitiesOwn;
+exports.getMeActivitiesTracks = getMeActivitiesTracks;
+exports.getMeFollowers = getMeFollowers;
+exports.getMeFollowings = getMeFollowings;
+exports.getMeFollowingsTracks = getMeFollowingsTracks;
+exports.getMeLikesPlaylists = getMeLikesPlaylists;
+exports.getMeLikesTracks = getMeLikesTracks;
+exports.getMePlaylists = getMePlaylists;
+exports.getMeTracks = getMeTracks;
+exports.getPlaylist = getPlaylist;
+exports.getPlaylistReposts = getPlaylistReposts;
+exports.getPlaylistTracks = getPlaylistTracks;
+exports.getRelatedTracks = getRelatedTracks;
+exports.getSoundCloudWidgetUrl = getSoundCloudWidgetUrl;
+exports.getTrack = getTrack;
+exports.getTrackComments = getTrackComments;
+exports.getTrackLikes = getTrackLikes;
+exports.getTrackReposts = getTrackReposts;
+exports.getTrackStreams = getTrackStreams;
+exports.getUser = getUser;
+exports.getUserLikesPlaylists = getUserLikesPlaylists;
+exports.getUserLikesTracks = getUserLikesTracks;
+exports.getUserPlaylists = getUserPlaylists;
+exports.getUserToken = getUserToken;
+exports.getUserTracks = getUserTracks;
+exports.getUserWebProfiles = getUserWebProfiles;
+exports.likePlaylist = likePlaylist;
+exports.likeTrack = likeTrack;
+exports.paginate = paginate;
+exports.paginateItems = paginateItems;
+exports.refreshUserToken = refreshUserToken;
+exports.repostPlaylist = repostPlaylist;
+exports.repostTrack = repostTrack;
+exports.resolveUrl = resolveUrl;
+exports.scFetch = scFetch;
+exports.scFetchUrl = scFetchUrl;
+exports.searchPlaylists = searchPlaylists;
+exports.searchTracks = searchTracks;
+exports.searchUsers = searchUsers;
+exports.signOut = signOut;
+exports.unfollowUser = unfollowUser;
+exports.unlikePlaylist = unlikePlaylist;
+exports.unlikeTrack = unlikeTrack;
+exports.unrepostPlaylist = unrepostPlaylist;
+exports.unrepostTrack = unrepostTrack;
+exports.updatePlaylist = updatePlaylist;
+exports.updateTrack = updateTrack;
+//# sourceMappingURL=chunk-LNMDNQSC.js.map
+//# sourceMappingURL=chunk-LNMDNQSC.js.map