soundcloud-api-ts 1.0.0

package/dist/index.js

@@ -0,0 +1,915 @@
+'use strict';
+
+// src/client/http.ts
+var BASE_URL = "https://api.soundcloud.com";
+async function scFetch(options, refreshCtx) {
+  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;
+    }
+    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) {
+      throw new Error(
+        `SoundCloud API error: ${response.status} ${response.statusText}`
+      );
+    }
+    return response.json();
+  };
+  try {
+    return await execute();
+  } catch (err) {
+    if (refreshCtx?.onTokenRefresh && err instanceof Error && err.message.includes("401")) {
+      const newToken = await refreshCtx.onTokenRefresh();
+      refreshCtx.setToken(newToken.access_token, newToken.refresh_token);
+      return execute(newToken.access_token);
+    }
+    throw err;
+  }
+}
+
+// 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;
+  auth;
+  me;
+  users;
+  tracks;
+  playlists;
+  search;
+  resolve;
+  likes;
+  reposts;
+  constructor(config) {
+    this.config = config;
+    const getToken = () => this._accessToken;
+    const refreshCtx = config.onTokenRefresh ? {
+      getToken,
+      onTokenRefresh: async () => {
+        const result = await config.onTokenRefresh(this);
+        return result;
+      },
+      setToken: (a, r) => this.setToken(a, r)
+    } : void 0;
+    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. */
+  setToken(accessToken, refreshToken) {
+    this._accessToken = accessToken;
+    if (refreshToken !== void 0) this._refreshToken = refreshToken;
+  }
+  /** Clear stored tokens. */
+  clearToken() {
+    this._accessToken = void 0;
+    this._refreshToken = void 0;
+  }
+  /** Get the currently stored access token, if any. */
+  get accessToken() {
+    return this._accessToken;
+  }
+  /** Get the currently stored refresh token, if any. */
+  get refreshToken() {
+    return this._refreshToken;
+  }
+};
+((SoundCloudClient2) => {
+  class Auth {
+    constructor(config) {
+      this.config = config;
+    }
+    /** Build the authorization URL to redirect users to SoundCloud's login. */
+    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}`;
+    }
+    /** POST /oauth2/token — client_credentials grant */
+    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
+        })
+      });
+    }
+    /** POST /oauth2/token — authorization_code grant */
+    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)
+      });
+    }
+    /** POST /oauth2/token — refresh_token grant */
+    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
+        })
+      });
+    }
+    /**
+     * POST /sign-out — invalidates session.
+     *
+     * **Note:** This hits `https://secure.soundcloud.com`, NOT the regular
+     * `api.soundcloud.com` host used by all other endpoints.
+     */
+    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 /me */
+    async getMe(options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: "/me", method: "GET", token: t });
+    }
+    /** 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 /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 /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 /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 /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 /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 /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 });
+    }
+    /** PUT /me/followings/:user_urn — follow a user */
+    async follow(userUrn, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings/${userUrn}`, method: "PUT", token: t });
+    }
+    /** DELETE /me/followings/:user_urn — unfollow a user */
+    async unfollow(userUrn, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/me/followings/${userUrn}`, method: "DELETE", token: t });
+    }
+    /** 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 /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 /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 /users/:id */
+    async getUser(userId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/users/${userId}`, method: "GET", token: t });
+    }
+    /** GET /users/: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/: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 /users/: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 /users/: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 /users/: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 /users/: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 /users/: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 /tracks/:id */
+    async getTrack(trackId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/tracks/${trackId}`, method: "GET", token: t });
+    }
+    /** GET /tracks/: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 /tracks/: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 /tracks/: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 /tracks/: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 /tracks/: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/: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 });
+    }
+    /** PUT /tracks/:id — update track metadata */
+    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 /tracks/: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 /playlists/:id */
+    async getPlaylist(playlistId, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: `/playlists/${playlistId}`, method: "GET", token: t });
+    }
+    /** GET /playlists/: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 /playlists/: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 });
+    }
+    /** POST /playlists — create a playlist */
+    async create(params, options) {
+      const t = resolveToken(this.getToken, options?.token);
+      return this.fetch({ path: "/playlists", method: "POST", token: t, body: { playlist: params } });
+    }
+    /** PUT /playlists/:id — update a playlist */
+    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 /playlists/: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);
+    }
+    /** GET /tracks?q= */
+    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 });
+    }
+    /** GET /users?q= */
+    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 });
+    }
+    /** GET /playlists?q= */
+    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);
+    }
+    /** GET /resolve?url= */
+    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);
+    }
+    /** POST /likes/tracks/: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;
+      }
+    }
+    /** DELETE /likes/tracks/: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;
+      }
+    }
+    /** POST /likes/playlists/: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;
+      }
+    }
+    /** DELETE /likes/playlists/: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);
+    }
+    /** POST /reposts/tracks/: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;
+      }
+    }
+    /** DELETE /reposts/tracks/: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;
+      }
+    }
+    /** POST /reposts/playlists/: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;
+      }
+    }
+    /** DELETE /reposts/playlists/: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.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.refreshUserToken = refreshUserToken;
+exports.repostPlaylist = repostPlaylist;
+exports.repostTrack = repostTrack;
+exports.resolveUrl = resolveUrl;
+exports.scFetch = scFetch;
+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=index.js.map
+//# sourceMappingURL=index.js.map