soundcloud-api-ts 1.0.0

package/README.md

@@ -0,0 +1,249 @@
+# soundcloud-api-client
+
+A TypeScript client for the SoundCloud API. Zero dependencies, uses native `fetch` (Node 18+).
+
+## Install
+
+```bash
+npm install soundcloud-api-client
+```
+
+## Quick Start
+
+```ts
+import { SoundCloudClient } from "soundcloud-api-client";
+
+const sc = new SoundCloudClient({
+  clientId: "your-client-id",
+  clientSecret: "your-client-secret",
+  redirectUri: "https://yourapp.com/callback",
+});
+
+// Get a client token and store it
+const token = await sc.auth.getClientToken();
+sc.setToken(token.access_token);
+
+// Now all calls use the stored token automatically
+const results = await sc.search.tracks("electronic");
+const me = await sc.me.getMe();
+const track = await sc.tracks.getTrack(123456);
+const streams = await sc.tracks.getStreams(123456);
+```
+
+## OAuth 2.0 Flow
+
+```ts
+import { SoundCloudClient, generateCodeVerifier, generateCodeChallenge } from "soundcloud-api-client";
+
+const sc = new SoundCloudClient({
+  clientId: "...",
+  clientSecret: "...",
+  redirectUri: "https://yourapp.com/callback",
+  // Optional: auto-refresh tokens on 401
+  onTokenRefresh: async (client) => {
+    const newToken = await client.auth.refreshUserToken(client.refreshToken!);
+    // Persist newToken to your DB here
+    return newToken;
+  },
+});
+
+// 1. Generate PKCE pair (for public clients / SPAs)
+const verifier = generateCodeVerifier();
+const challenge = await generateCodeChallenge(verifier);
+
+// 2. Build authorization URL and redirect the user
+const authUrl = sc.auth.getAuthorizationUrl({ state: "random", codeChallenge: challenge });
+// → redirect user to authUrl
+
+// 3. Exchange the code for tokens (in your callback handler)
+const token = await sc.auth.getUserToken(code, verifier);
+sc.setToken(token.access_token, token.refresh_token);
+
+// 4. Use the API — token is used automatically
+const me = await sc.me.getMe();
+const tracks = await sc.search.tracks("lofi beats");
+
+// 5. Override token per-call if needed
+const otherMe = await sc.me.getMe({ token: "other-users-token" });
+
+// 6. Refresh manually if needed
+const refreshed = await sc.auth.refreshUserToken(token.refresh_token);
+sc.setToken(refreshed.access_token, refreshed.refresh_token);
+
+// 7. Sign out
+await sc.auth.signOut(token.access_token);
+sc.clearToken();
+```
+
+## Client Class
+
+The `SoundCloudClient` class organizes all endpoints into namespaces. Token is resolved automatically when `setToken()` has been called. Override per-call via `{ token: "..." }` options object.
+
+```ts
+const sc = new SoundCloudClient({ clientId, clientSecret, redirectUri });
+
+// Token management
+sc.setToken(accessToken, refreshToken?)
+sc.clearToken()
+sc.accessToken   // getter
+sc.refreshToken  // getter
+
+// Auth
+sc.auth.getAuthorizationUrl({ state?, codeChallenge? })
+sc.auth.getClientToken()
+sc.auth.getUserToken(code, codeVerifier?)
+sc.auth.refreshUserToken(refreshToken)
+sc.auth.signOut(accessToken)
+
+// Me (authenticated user) — primary params first, options last
+sc.me.getMe(options?)
+sc.me.getActivities(limit?, options?)
+sc.me.getActivitiesOwn(limit?, options?)
+sc.me.getActivitiesTracks(limit?, options?)
+sc.me.getLikesTracks(limit?, options?)
+sc.me.getLikesPlaylists(limit?, options?)
+sc.me.getFollowings(limit?, options?)
+sc.me.getFollowingsTracks(limit?, options?)
+sc.me.follow(userUrn, options?)
+sc.me.unfollow(userUrn, options?)
+sc.me.getFollowers(limit?, options?)
+sc.me.getPlaylists(limit?, options?)
+sc.me.getTracks(limit?, options?)
+
+// Users
+sc.users.getUser(userId, options?)
+sc.users.getFollowers(userId, limit?, options?)
+sc.users.getFollowings(userId, limit?, options?)
+sc.users.getTracks(userId, limit?, options?)
+sc.users.getPlaylists(userId, limit?, options?)
+sc.users.getLikesTracks(userId, limit?, cursor?, options?)
+sc.users.getLikesPlaylists(userId, limit?, options?)
+sc.users.getWebProfiles(userId, options?)
+
+// Tracks
+sc.tracks.getTrack(trackId, options?)
+sc.tracks.getStreams(trackId, options?)
+sc.tracks.getComments(trackId, limit?, options?)
+sc.tracks.createComment(trackId, body, timestamp?, options?)
+sc.tracks.getLikes(trackId, limit?, options?)
+sc.tracks.getReposts(trackId, limit?, options?)
+sc.tracks.getRelated(trackId, limit?, options?)
+sc.tracks.update(trackId, params, options?)
+sc.tracks.delete(trackId, options?)
+
+// Playlists
+sc.playlists.getPlaylist(playlistId, options?)
+sc.playlists.getTracks(playlistId, limit?, offset?, options?)
+sc.playlists.getReposts(playlistId, limit?, options?)
+sc.playlists.create(params, options?)
+sc.playlists.update(playlistId, params, options?)
+sc.playlists.delete(playlistId, options?)
+
+// Likes
+sc.likes.likeTrack(trackId, options?)
+sc.likes.unlikeTrack(trackId, options?)
+sc.likes.likePlaylist(playlistId, options?)
+sc.likes.unlikePlaylist(playlistId, options?)
+
+// Reposts
+sc.reposts.repostTrack(trackId, options?)
+sc.reposts.unrepostTrack(trackId, options?)
+sc.reposts.repostPlaylist(playlistId, options?)
+sc.reposts.unrepostPlaylist(playlistId, options?)
+
+// Search
+sc.search.tracks(query, pageNumber?, options?)
+sc.search.users(query, pageNumber?, options?)
+sc.search.playlists(query, pageNumber?, options?)
+
+// Resolve
+sc.resolve.resolveUrl(url, options?)
+```
+
+Where `options` is `{ token?: string }` — only needed to override the stored token.
+
+## Standalone Functions
+
+Every endpoint is also available as a standalone function (token is always required):
+
+```ts
+import {
+  getClientToken, getUserToken, getAuthorizationUrl,
+  generateCodeVerifier, generateCodeChallenge,
+  getMe, searchTracks,
+} from "soundcloud-api-client";
+
+const token = await getClientToken("clientId", "clientSecret");
+const me = await getMe(token.access_token);
+const tracks = await searchTracks(token.access_token, "lo-fi");
+
+// Build auth URL
+const authUrl = getAuthorizationUrl("clientId", "https://yourapp.com/callback", { state: "xyz" });
+```
+
+## Types
+
+All response types match the SoundCloud API spec:
+
+```ts
+import type {
+  SoundCloudUser,
+  SoundCloudMe,
+  SoundCloudTrack,
+  SoundCloudPlaylist,
+  SoundCloudComment,
+  SoundCloudToken,
+  SoundCloudStreams,
+  SoundCloudWebProfile,
+  SoundCloudActivity,
+  SoundCloudActivitiesResponse,
+  SoundCloudPaginatedResponse,
+  TokenOption,
+} from "soundcloud-api-client/types";
+```
+
+## PKCE (Proof Key for Code Exchange)
+
+For public clients (SPAs, mobile apps), use PKCE:
+
+```ts
+import { generateCodeVerifier, generateCodeChallenge } from "soundcloud-api-client";
+
+const verifier = generateCodeVerifier();
+const challenge = await generateCodeChallenge(verifier);
+
+// Pass challenge when building auth URL
+const url = sc.auth.getAuthorizationUrl({ codeChallenge: challenge });
+
+// Pass verifier when exchanging the code
+const token = await sc.auth.getUserToken(code, verifier);
+```
+
+## Pagination
+
+Paginated endpoints return `SoundCloudPaginatedResponse<T>`:
+
+```ts
+interface SoundCloudPaginatedResponse<T> {
+  collection: T[];
+  next_href: string; // URL for next page
+}
+```
+
+## Utilities
+
+```ts
+import { getSoundCloudWidgetUrl } from "soundcloud-api-client";
+
+// Generate a SoundCloud embed widget URL
+const widgetUrl = getSoundCloudWidgetUrl(trackId);
+```
+
+## Requirements
+
+- Node.js 18+ (uses native `fetch`)
+- SoundCloud API credentials
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,440 @@
+import { SoundCloudTrack, SoundCloudPlaylist, SoundCloudToken, SoundCloudMe, SoundCloudActivitiesResponse, SoundCloudPaginatedResponse, SoundCloudUser, SoundCloudWebProfile, SoundCloudStreams, SoundCloudComment } from './types/index.mjs';
+export { SoundCloudActivity, SoundCloudCommentUser, SoundCloudQuota, SoundCloudSubscription, SoundCloudSubscriptionProduct } from './types/index.mjs';
+
+interface RequestOptions {
+    path: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    token?: string;
+    body?: Record<string, unknown> | FormData | URLSearchParams;
+    contentType?: string;
+}
+interface AutoRefreshContext {
+    getToken: () => string | undefined;
+    onTokenRefresh?: () => Promise<{
+        access_token: string;
+        refresh_token?: string;
+    }>;
+    setToken: (accessToken: string, refreshToken?: string) => void;
+}
+/**
+ * Make a request to the SoundCloud API using native fetch.
+ * Returns parsed JSON, or for 302 redirects returns the Location header.
+ */
+declare function scFetch<T>(options: RequestOptions, refreshCtx?: AutoRefreshContext): Promise<T>;
+
+interface UpdateTrackParams {
+    title?: string;
+    description?: string;
+    genre?: string;
+    tag_list?: string;
+    sharing?: "public" | "private";
+    downloadable?: boolean;
+    purchase_url?: string;
+    purchase_title?: string;
+    release?: string;
+    release_day?: number;
+    release_month?: number;
+    release_year?: number;
+    label_name?: string;
+    license?: string;
+    isrc?: string;
+    bpm?: number;
+    key_signature?: string;
+}
+/** PUT /tracks/:id — updates a track's metadata */
+declare const updateTrack: (token: string, trackId: string | number, params: UpdateTrackParams) => Promise<SoundCloudTrack>;
+
+interface CreatePlaylistParams {
+    title: string;
+    description?: string;
+    sharing?: "public" | "private";
+    tracks?: {
+        urn: string;
+    }[];
+    ean?: string;
+    genre?: string;
+    label_name?: string;
+    license?: string;
+    permalink?: string;
+    purchase_title?: string;
+    purchase_url?: string;
+    release?: string;
+    release_date?: string;
+    set_type?: "album" | "playlist";
+    tag_list?: string;
+}
+/** POST /playlists — creates a playlist */
+declare const createPlaylist: (token: string, params: CreatePlaylistParams) => Promise<SoundCloudPlaylist>;
+
+interface UpdatePlaylistParams {
+    title?: string;
+    description?: string;
+    sharing?: "public" | "private";
+    tracks?: {
+        urn: string;
+    }[];
+    ean?: string;
+    genre?: string;
+    label_name?: string;
+    license?: string;
+    permalink?: string;
+    purchase_title?: string;
+    purchase_url?: string;
+    release?: string;
+    release_date?: string;
+    set_type?: "album" | "playlist";
+    tag_list?: string;
+}
+/** PUT /playlists/:id — updates a playlist */
+declare const updatePlaylist: (token: string, playlistId: string | number, params: UpdatePlaylistParams) => Promise<SoundCloudPlaylist>;
+
+interface SoundCloudClientConfig {
+    clientId: string;
+    clientSecret: string;
+    redirectUri?: string;
+    /** Called automatically when a request returns 401. Return new tokens to retry. */
+    onTokenRefresh?: (client: SoundCloudClient) => Promise<SoundCloudToken>;
+}
+/** Optional token override, passed as the last parameter to client methods. */
+interface TokenOption {
+    token?: string;
+}
+/** Resolve a token: use explicit override, fall back to stored, or throw. */
+type TokenGetter = () => string | undefined;
+declare class SoundCloudClient {
+    private config;
+    private _accessToken?;
+    private _refreshToken?;
+    auth: SoundCloudClient.Auth;
+    me: SoundCloudClient.Me;
+    users: SoundCloudClient.Users;
+    tracks: SoundCloudClient.Tracks;
+    playlists: SoundCloudClient.Playlists;
+    search: SoundCloudClient.Search;
+    resolve: SoundCloudClient.Resolve;
+    likes: SoundCloudClient.Likes;
+    reposts: SoundCloudClient.Reposts;
+    constructor(config: SoundCloudClientConfig);
+    /** Store an access token (and optionally refresh token) on this client instance. */
+    setToken(accessToken: string, refreshToken?: string): void;
+    /** Clear stored tokens. */
+    clearToken(): void;
+    /** Get the currently stored access token, if any. */
+    get accessToken(): string | undefined;
+    /** Get the currently stored refresh token, if any. */
+    get refreshToken(): string | undefined;
+}
+declare namespace SoundCloudClient {
+    class Auth {
+        private config;
+        constructor(config: SoundCloudClientConfig);
+        /** Build the authorization URL to redirect users to SoundCloud's login. */
+        getAuthorizationUrl(options?: {
+            state?: string;
+            codeChallenge?: string;
+        }): string;
+        /** POST /oauth2/token — client_credentials grant */
+        getClientToken(): Promise<SoundCloudToken>;
+        /** POST /oauth2/token — authorization_code grant */
+        getUserToken(code: string, codeVerifier?: string): Promise<SoundCloudToken>;
+        /** POST /oauth2/token — refresh_token grant */
+        refreshUserToken(refreshToken: string): Promise<SoundCloudToken>;
+        /**
+         * POST /sign-out — invalidates session.
+         *
+         * **Note:** This hits `https://secure.soundcloud.com`, NOT the regular
+         * `api.soundcloud.com` host used by all other endpoints.
+         */
+        signOut(accessToken: string): Promise<void>;
+    }
+    class Me {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /me */
+        getMe(options?: TokenOption): Promise<SoundCloudMe>;
+        /** GET /me/activities */
+        getActivities(limit?: number, options?: TokenOption): Promise<SoundCloudActivitiesResponse>;
+        /** GET /me/activities/all/own */
+        getActivitiesOwn(limit?: number, options?: TokenOption): Promise<SoundCloudActivitiesResponse>;
+        /** GET /me/activities/tracks */
+        getActivitiesTracks(limit?: number, options?: TokenOption): Promise<SoundCloudActivitiesResponse>;
+        /** GET /me/likes/tracks */
+        getLikesTracks(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** GET /me/likes/playlists */
+        getLikesPlaylists(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+        /** GET /me/followings */
+        getFollowings(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /me/followings/tracks */
+        getFollowingsTracks(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** PUT /me/followings/:user_urn — follow a user */
+        follow(userUrn: string | number, options?: TokenOption): Promise<void>;
+        /** DELETE /me/followings/:user_urn — unfollow a user */
+        unfollow(userUrn: string | number, options?: TokenOption): Promise<void>;
+        /** GET /me/followers */
+        getFollowers(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /me/playlists */
+        getPlaylists(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+        /** GET /me/tracks */
+        getTracks(limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+    }
+    class Users {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /users/:id */
+        getUser(userId: string | number, options?: TokenOption): Promise<SoundCloudUser>;
+        /** GET /users/:id/followers */
+        getFollowers(userId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /users/:id/followings */
+        getFollowings(userId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /users/:id/tracks */
+        getTracks(userId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** GET /users/:id/playlists */
+        getPlaylists(userId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+        /** GET /users/:id/likes/tracks */
+        getLikesTracks(userId: string | number, limit?: number, cursor?: string, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** GET /users/:id/likes/playlists */
+        getLikesPlaylists(userId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+        /** GET /users/:id/web-profiles */
+        getWebProfiles(userId: string | number, options?: TokenOption): Promise<SoundCloudWebProfile[]>;
+    }
+    class Tracks {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /tracks/:id */
+        getTrack(trackId: string | number, options?: TokenOption): Promise<SoundCloudTrack>;
+        /** GET /tracks/:id/streams */
+        getStreams(trackId: string | number, options?: TokenOption): Promise<SoundCloudStreams>;
+        /** GET /tracks/:id/comments */
+        getComments(trackId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudComment>>;
+        /** POST /tracks/:id/comments */
+        createComment(trackId: string | number, body: string, timestamp?: number, options?: TokenOption): Promise<SoundCloudComment>;
+        /** GET /tracks/:id/favoriters */
+        getLikes(trackId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /tracks/:id/reposters */
+        getReposts(trackId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /tracks/:id/related */
+        getRelated(trackId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudTrack[]>;
+        /** PUT /tracks/:id — update track metadata */
+        update(trackId: string | number, params: UpdateTrackParams, options?: TokenOption): Promise<SoundCloudTrack>;
+        /** DELETE /tracks/:id */
+        delete(trackId: string | number, options?: TokenOption): Promise<void>;
+    }
+    class Playlists {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /playlists/:id */
+        getPlaylist(playlistId: string | number, options?: TokenOption): Promise<SoundCloudPlaylist>;
+        /** GET /playlists/:id/tracks */
+        getTracks(playlistId: string | number, limit?: number, offset?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** GET /playlists/:id/reposters */
+        getReposts(playlistId: string | number, limit?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** POST /playlists — create a playlist */
+        create(params: CreatePlaylistParams, options?: TokenOption): Promise<SoundCloudPlaylist>;
+        /** PUT /playlists/:id — update a playlist */
+        update(playlistId: string | number, params: UpdatePlaylistParams, options?: TokenOption): Promise<SoundCloudPlaylist>;
+        /** DELETE /playlists/:id */
+        delete(playlistId: string | number, options?: TokenOption): Promise<void>;
+    }
+    class Search {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /tracks?q= */
+        tracks(query: string, pageNumber?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+        /** GET /users?q= */
+        users(query: string, pageNumber?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+        /** GET /playlists?q= */
+        playlists(query: string, pageNumber?: number, options?: TokenOption): Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+    }
+    class Resolve {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** GET /resolve?url= */
+        resolveUrl(url: string, options?: TokenOption): Promise<string>;
+    }
+    class Likes {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** POST /likes/tracks/:id */
+        likeTrack(trackId: string | number, options?: TokenOption): Promise<boolean>;
+        /** DELETE /likes/tracks/:id */
+        unlikeTrack(trackId: string | number, options?: TokenOption): Promise<boolean>;
+        /** POST /likes/playlists/:id */
+        likePlaylist(playlistId: string | number, options?: TokenOption): Promise<boolean>;
+        /** DELETE /likes/playlists/:id */
+        unlikePlaylist(playlistId: string | number, options?: TokenOption): Promise<boolean>;
+    }
+    class Reposts {
+        private getToken;
+        private refreshCtx?;
+        constructor(getToken: TokenGetter, refreshCtx?: AutoRefreshContext | undefined);
+        private fetch;
+        /** POST /reposts/tracks/:id */
+        repostTrack(trackId: string | number, options?: TokenOption): Promise<boolean>;
+        /** DELETE /reposts/tracks/:id */
+        unrepostTrack(trackId: string | number, options?: TokenOption): Promise<boolean>;
+        /** POST /reposts/playlists/:id */
+        repostPlaylist(playlistId: string | number, options?: TokenOption): Promise<boolean>;
+        /** DELETE /reposts/playlists/:id */
+        unrepostPlaylist(playlistId: string | number, options?: TokenOption): Promise<boolean>;
+    }
+}
+
+declare const getClientToken: (clientId: string, clientSecret: string) => Promise<SoundCloudToken>;
+
+declare const getUserToken: (clientId: string, clientSecret: string, redirectUri: string, code: string, codeVerifier?: string) => Promise<SoundCloudToken>;
+
+declare const refreshUserToken: (clientId: string, clientSecret: string, redirectUri: string, refreshToken: string) => Promise<SoundCloudToken>;
+
+/**
+ * POST /sign-out — invalidates session associated with current token.
+ *
+ * **Note:** This hits `https://secure.soundcloud.com`, NOT the regular
+ * `api.soundcloud.com` host used by all other endpoints.
+ */
+declare const signOut: (accessToken: string) => Promise<void>;
+
+/**
+ * Build the SoundCloud authorization URL for the OAuth 2.0 code flow.
+ *
+ * Redirect the user to this URL so they can grant access to your application.
+ */
+declare function getAuthorizationUrl(clientId: string, redirectUri: string, options?: {
+    state?: string;
+    codeChallenge?: string;
+}): string;
+
+/**
+ * Generate a random PKCE code verifier (43 chars, base64url).
+ * Works in Node 18+ and modern browsers via globalThis.crypto.
+ */
+declare function generateCodeVerifier(): string;
+/**
+ * Derive the S256 code challenge from a code verifier.
+ * Uses the Web Crypto API (SubtleCrypto) available in Node 18+ and browsers.
+ */
+declare function generateCodeChallenge(verifier: string): Promise<string>;
+
+declare const getMe: (token: string) => Promise<SoundCloudMe>;
+
+declare const getUser: (token: string, userId: string | number) => Promise<SoundCloudUser>;
+
+declare const getFollowers: (token: string, userId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+declare const getFollowings: (token: string, userId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+declare const getUserTracks: (token: string, userId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+
+declare const getUserPlaylists: (token: string, userId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+
+declare const getUserLikesTracks: (token: string, userId: string | number, limit?: number, cursor?: string) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+
+declare const getUserLikesPlaylists: (token: string, userId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+
+/** GET /users/:id/web-profiles — returns user's external links */
+declare const getUserWebProfiles: (token: string, userId: string | number) => Promise<SoundCloudWebProfile[]>;
+
+declare const getTrack: (token: string, trackId: string | number) => Promise<SoundCloudTrack>;
+
+declare const getTrackComments: (token: string, trackId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudComment>>;
+
+/** POST /tracks/:id/comments — creates a comment on a track */
+declare const createTrackComment: (token: string, trackId: string | number, body: string, timestamp?: number) => Promise<SoundCloudComment>;
+
+declare const getTrackLikes: (token: string, trackId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+declare const getTrackReposts: (token: string, trackId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+declare const getRelatedTracks: (token: string, trackId: string | number, limit?: number) => Promise<SoundCloudTrack[]>;
+
+/** GET /tracks/:id/streams — returns streamable URLs */
+declare const getTrackStreams: (token: string, trackId: string | number) => Promise<SoundCloudStreams>;
+
+declare const likeTrack: (token: string, trackId: string | number) => Promise<boolean>;
+
+/** DELETE /likes/tracks/:id — unlikes a track */
+declare const unlikeTrack: (token: string, trackId: string | number) => Promise<boolean>;
+
+/** DELETE /tracks/:id — deletes a track */
+declare const deleteTrack: (token: string, trackId: string | number) => Promise<void>;
+
+declare const getPlaylist: (token: string, playlistId: string | number) => Promise<SoundCloudPlaylist>;
+
+declare const getPlaylistTracks: (token: string, playlistId: string | number, limit?: number, offset?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+
+declare const getPlaylistReposts: (token: string, playlistId: string | number, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+/** DELETE /playlists/:id — deletes a playlist */
+declare const deletePlaylist: (token: string, playlistId: string | number) => Promise<void>;
+
+declare const searchTracks: (token: string, query: string, pageNumber?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+
+declare const searchUsers: (token: string, query: string, pageNumber?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+declare const searchPlaylists: (token: string, query: string, pageNumber?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+
+declare const resolveUrl: (token: string, url: string) => Promise<string>;
+
+/** GET /me/activities */
+declare const getMeActivities: (token: string, limit?: number) => Promise<SoundCloudActivitiesResponse>;
+/** GET /me/activities/all/own */
+declare const getMeActivitiesOwn: (token: string, limit?: number) => Promise<SoundCloudActivitiesResponse>;
+/** GET /me/activities/tracks */
+declare const getMeActivitiesTracks: (token: string, limit?: number) => Promise<SoundCloudActivitiesResponse>;
+
+/** GET /me/likes/tracks */
+declare const getMeLikesTracks: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+/** GET /me/likes/playlists */
+declare const getMeLikesPlaylists: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+
+/** GET /me/followings */
+declare const getMeFollowings: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+/** GET /me/followings/tracks */
+declare const getMeFollowingsTracks: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+/** PUT /me/followings/:user_urn — follow a user */
+declare const followUser: (token: string, userUrn: string | number) => Promise<void>;
+/** DELETE /me/followings/:user_urn — unfollow a user */
+declare const unfollowUser: (token: string, userUrn: string | number) => Promise<void>;
+
+/** GET /me/followers */
+declare const getMeFollowers: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudUser>>;
+
+/** GET /me/playlists */
+declare const getMePlaylists: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudPlaylist>>;
+
+/** GET /me/tracks */
+declare const getMeTracks: (token: string, limit?: number) => Promise<SoundCloudPaginatedResponse<SoundCloudTrack>>;
+
+/** POST /likes/playlists/:id */
+declare const likePlaylist: (token: string, playlistId: string | number) => Promise<boolean>;
+/** DELETE /likes/playlists/:id */
+declare const unlikePlaylist: (token: string, playlistId: string | number) => Promise<boolean>;
+
+/** POST /reposts/tracks/:id */
+declare const repostTrack: (token: string, trackId: string | number) => Promise<boolean>;
+/** DELETE /reposts/tracks/:id */
+declare const unrepostTrack: (token: string, trackId: string | number) => Promise<boolean>;
+/** POST /reposts/playlists/:id */
+declare const repostPlaylist: (token: string, playlistId: string | number) => Promise<boolean>;
+/** DELETE /reposts/playlists/:id */
+declare const unrepostPlaylist: (token: string, playlistId: string | number) => Promise<boolean>;
+
+/**
+ * Returns an encoded SoundCloud widget embed URL for a given track ID.
+ */
+declare const getSoundCloudWidgetUrl: (trackId: string | number) => string;
+
+export { type CreatePlaylistParams, type RequestOptions, SoundCloudActivitiesResponse, SoundCloudClient, type SoundCloudClientConfig, SoundCloudComment, SoundCloudMe, SoundCloudPaginatedResponse, SoundCloudPlaylist, SoundCloudStreams, SoundCloudToken, SoundCloudTrack, SoundCloudUser, SoundCloudWebProfile, type TokenOption, type UpdatePlaylistParams, type UpdateTrackParams, createPlaylist, createTrackComment, deletePlaylist, deleteTrack, followUser, generateCodeChallenge, generateCodeVerifier, getAuthorizationUrl, getClientToken, getFollowers, getFollowings, getMe, getMeActivities, getMeActivitiesOwn, getMeActivitiesTracks, getMeFollowers, getMeFollowings, getMeFollowingsTracks, getMeLikesPlaylists, getMeLikesTracks, getMePlaylists, getMeTracks, getPlaylist, getPlaylistReposts, getPlaylistTracks, getRelatedTracks, getSoundCloudWidgetUrl, getTrack, getTrackComments, getTrackLikes, getTrackReposts, getTrackStreams, getUser, getUserLikesPlaylists, getUserLikesTracks, getUserPlaylists, getUserToken, getUserTracks, getUserWebProfiles, likePlaylist, likeTrack, refreshUserToken, repostPlaylist, repostTrack, resolveUrl, scFetch, searchPlaylists, searchTracks, searchUsers, signOut, unfollowUser, unlikePlaylist, unlikeTrack, unrepostPlaylist, unrepostTrack, updatePlaylist, updateTrack };