soundcloud-api-ts-next 1.2.0 → 1.3.0

package/README.md

@@ -24,10 +24,13 @@ import { createSoundCloudRoutes } from "soundcloud-api-ts-next/server";
 const sc = createSoundCloudRoutes({
   clientId: process.env.SOUNDCLOUD_CLIENT_ID!,
   clientSecret: process.env.SOUNDCLOUD_CLIENT_SECRET!,
+  redirectUri: process.env.SOUNDCLOUD_REDIRECT_URI, // Required for OAuth
 });
 
 const handler = sc.handler();
 export const GET = handler;
+export const POST = handler;
+export const DELETE = handler;
 ```
 
 **Pages Router** (`pages/api/soundcloud/[...route].ts`):
@@ -38,6 +41,7 @@ import { createSoundCloudRoutes } from "soundcloud-api-ts-next/server";
 const sc = createSoundCloudRoutes({
   clientId: process.env.SOUNDCLOUD_CLIENT_ID!,
   clientSecret: process.env.SOUNDCLOUD_CLIENT_SECRET!,
+  redirectUri: process.env.SOUNDCLOUD_REDIRECT_URI,
 });
 
 export default sc.pagesHandler();
@@ -59,6 +63,131 @@ export default function Layout({ children }) {
 }
 ```
 
+## Authentication (OAuth + PKCE)
+
+soundcloud-api-ts-next includes a complete OAuth flow with PKCE for secure user authentication.
+
+### Setup
+
+1. Add `redirectUri` to your server config (see above)
+2. Set your SoundCloud app's redirect URI to match (e.g., `http://localhost:3000/callback`)
+
+### Login Flow
+
+```tsx
+import { useSCAuth } from "soundcloud-api-ts-next";
+
+function LoginButton() {
+  const { isAuthenticated, user, login, logout, loading } = useSCAuth();
+
+  if (loading) return <p>Loading...</p>;
+
+  if (isAuthenticated) {
+    return (
+      <div>
+        <p>Logged in as {user?.username}</p>
+        <button onClick={logout}>Logout</button>
+      </div>
+    );
+  }
+
+  return <button onClick={login}>Login with SoundCloud</button>;
+}
+```
+
+### Callback Page
+
+Create a callback page that handles the OAuth redirect:
+
+```tsx
+// app/callback/page.tsx
+"use client";
+
+import { useEffect } from "react";
+import { useSearchParams, useRouter } from "next/navigation";
+import { useSCAuth } from "soundcloud-api-ts-next";
+
+export default function CallbackPage() {
+  const searchParams = useSearchParams();
+  const router = useRouter();
+  const { handleCallback } = useSCAuth();
+
+  useEffect(() => {
+    const code = searchParams.get("code");
+    const state = searchParams.get("state");
+    if (code && state) {
+      handleCallback(code, state).then(() => {
+        router.push("/");
+      });
+    }
+  }, [searchParams]);
+
+  return <p>Authenticating...</p>;
+}
+```
+
+### Authenticated User Hooks
+
+These hooks fetch data for the currently logged-in user. They require authentication and automatically pass the access token.
+
+| Hook | Returns | Description |
+|------|---------|-------------|
+| `useMe()` | `HookResult<SoundCloudUser>` | Current user's profile |
+| `useMeTracks()` | `HookResult<SoundCloudTrack[]>` | Current user's tracks |
+| `useMeLikes()` | `HookResult<SoundCloudTrack[]>` | Current user's liked tracks |
+| `useMePlaylists()` | `HookResult<SoundCloudPlaylist[]>` | Current user's playlists |
+| `useMeFollowings()` | `HookResult<SoundCloudUser[]>` | Who current user follows |
+| `useMeFollowers()` | `HookResult<SoundCloudUser[]>` | Current user's followers |
+
+```tsx
+import { useMe, useMeTracks, useMeLikes } from "soundcloud-api-ts-next";
+
+function MyProfile() {
+  const { data: me } = useMe();
+  const { data: tracks } = useMeTracks();
+  const { data: likes } = useMeLikes();
+
+  if (!me) return null;
+
+  return (
+    <div>
+      <h1>{me.username}</h1>
+      <p>{tracks?.length} tracks, {likes?.length} likes</p>
+    </div>
+  );
+}
+```
+
+### Action Hooks
+
+Mutation hooks for user actions. All require authentication.
+
+| Hook | Methods | Description |
+|------|---------|-------------|
+| `useFollow()` | `follow(userId)`, `unfollow(userId)` | Follow/unfollow a user |
+| `useLike()` | `likeTrack(trackId)`, `unlikeTrack(trackId)` | Like/unlike a track |
+| `useRepost()` | `repostTrack(trackId)`, `unrepostTrack(trackId)` | Repost/unrepost a track |
+
+```tsx
+import { useLike, useFollow } from "soundcloud-api-ts-next";
+
+function TrackActions({ trackId, artistId }) {
+  const { likeTrack, unlikeTrack, loading: likeLoading } = useLike();
+  const { follow, loading: followLoading } = useFollow();
+
+  return (
+    <div>
+      <button onClick={() => likeTrack(trackId)} disabled={likeLoading}>
+        ❤️ Like
+      </button>
+      <button onClick={() => follow(artistId)} disabled={followLoading}>
+        ➕ Follow Artist
+      </button>
+    </div>
+  );
+}
+```
+
 ## Hooks
 
 All hooks return `{ data, loading, error }`.
@@ -103,6 +232,39 @@ All hooks return `{ data, loading, error }`.
 
 All routes are available via the catch-all handler and as individual methods on the routes object.
 
+### Auth Routes
+
+| Route | Method | Description |
+|-------|--------|-------------|
+| `/auth/login` | GET | Get SoundCloud OAuth URL (PKCE) |
+| `/auth/callback?code=...&state=...` | GET | Exchange auth code for tokens |
+| `/auth/refresh` | POST | Refresh access token |
+| `/auth/logout` | POST | Sign out / revoke token |
+
+### Me Routes (require `Authorization: Bearer <token>` header)
+
+| Route | Method | Description |
+|-------|--------|-------------|
+| `/me` | GET | Current user profile |
+| `/me/tracks` | GET | Current user's tracks |
+| `/me/likes` | GET | Current user's liked tracks |
+| `/me/playlists` | GET | Current user's playlists |
+| `/me/followings` | GET | Who current user follows |
+| `/me/followers` | GET | Current user's followers |
+
+### Action Routes (require `Authorization: Bearer <token>` header)
+
+| Route | Method | Description |
+|-------|--------|-------------|
+| `/me/follow/:userId` | POST | Follow a user |
+| `/me/follow/:userId` | DELETE | Unfollow a user |
+| `/tracks/:id/like` | POST | Like a track |
+| `/tracks/:id/like` | DELETE | Unlike a track |
+| `/tracks/:id/repost` | POST | Repost a track |
+| `/tracks/:id/repost` | DELETE | Unrepost a track |
+| `/playlists/:id/like` | POST/DELETE | Like/unlike a playlist |
+| `/playlists/:id/repost` | POST/DELETE | Repost/unrepost a playlist |
+
 ### Search
 
 | Route | Method | Description |
@@ -201,6 +363,9 @@ import type {
   SoundCloudPlaylist,
   SoundCloudComment,
   SoundCloudStreams,
+  SoundCloudToken,
+  AuthState,
+  MutationResult,
 } from "soundcloud-api-ts-next";
 ```
 

package/dist/index.cjs

@@ -4,13 +4,98 @@
 var _react = require('react');
 var _jsxruntime = require('react/jsx-runtime');
 var SoundCloudContext = _react.createContext.call(void 0, {
-  apiPrefix: "/api/soundcloud"
+  apiPrefix: "/api/soundcloud",
+  user: null,
+  accessToken: null,
+  isAuthenticated: false,
+  authLoading: false,
+  login: () => {
+  },
+  logout: async () => {
+  },
+  _setAuth: () => {
+  }
 });
 function SoundCloudProvider({
   apiPrefix = "/api/soundcloud",
   children
 }) {
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SoundCloudContext.Provider, { value: { apiPrefix }, children });
+  const [accessToken, setAccessToken] = _react.useState.call(void 0, null);
+  const [refreshToken, setRefreshToken] = _react.useState.call(void 0, null);
+  const [expiresAt, setExpiresAt] = _react.useState.call(void 0, null);
+  const [user, setUser] = _react.useState.call(void 0, null);
+  const [authLoading, setAuthLoading] = _react.useState.call(void 0, false);
+  const _setAuth = _react.useCallback.call(void 0, 
+    (auth) => {
+      setAccessToken(auth.accessToken);
+      setRefreshToken(auth.refreshToken);
+      setExpiresAt(Date.now() + auth.expiresIn * 1e3);
+    },
+    []
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!accessToken) {
+      setUser(null);
+      return;
+    }
+    let cancelled = false;
+    setAuthLoading(true);
+    fetch(`${apiPrefix}/me`, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    }).then((res) => {
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return res.json();
+    }).then((data) => {
+      if (!cancelled) setUser(data);
+    }).catch(() => {
+      if (!cancelled) setUser(null);
+    }).finally(() => {
+      if (!cancelled) setAuthLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [accessToken, apiPrefix]);
+  const login = _react.useCallback.call(void 0, () => {
+    fetch(`${apiPrefix}/auth/login`).then((res) => res.json()).then((data) => {
+      if (data.url) {
+        window.location.href = data.url;
+      }
+    }).catch(console.error);
+  }, [apiPrefix]);
+  const logout = _react.useCallback.call(void 0, async () => {
+    try {
+      if (accessToken) {
+        await fetch(`${apiPrefix}/auth/logout`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ access_token: accessToken })
+        });
+      }
+    } catch (e) {
+    }
+    setAccessToken(null);
+    setRefreshToken(null);
+    setExpiresAt(null);
+    setUser(null);
+  }, [accessToken, apiPrefix]);
+  const isAuthenticated = accessToken !== null && user !== null;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    SoundCloudContext.Provider,
+    {
+      value: {
+        apiPrefix,
+        user,
+        accessToken,
+        isAuthenticated,
+        authLoading,
+        login,
+        logout,
+        _setAuth
+      },
+      children
+    }
+  );
 }
 function useSoundCloudContext() {
   return _react.useContext.call(void 0, SoundCloudContext);
@@ -639,6 +724,246 @@ function useInfinitePlaylistTracks(playlistId) {
   return useInfinite(url, !!playlistId);
 }
 
+// src/client/hooks/useSCAuth.ts
+function useSCAuth() {
+  const { user, isAuthenticated, authLoading, login, logout, _setAuth, apiPrefix } = useSoundCloudContext();
+  return {
+    user,
+    isAuthenticated,
+    loading: authLoading,
+    login,
+    logout,
+    /** Handle OAuth callback — exchange code for tokens */
+    async handleCallback(code, state) {
+      const res = await fetch(`${apiPrefix}/auth/callback?code=${encodeURIComponent(code)}&state=${encodeURIComponent(state)}`);
+      if (!res.ok) throw new Error(`Auth callback failed: ${res.status}`);
+      const tokens = await res.json();
+      _setAuth({
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresIn: tokens.expires_in
+      });
+      return tokens;
+    }
+  };
+}
+
+// src/client/hooks/useAuthFetch.ts
+
+function useAuthFetch(path) {
+  const { apiPrefix, accessToken, isAuthenticated } = useSoundCloudContext();
+  const [data, setData] = _react.useState.call(void 0, null);
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    if (!isAuthenticated || !accessToken) {
+      setData(null);
+      return;
+    }
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    fetch(`${apiPrefix}${path}`, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${accessToken}` }
+    }).then((res) => {
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return res.json();
+    }).then(setData).catch((err) => {
+      if (err.name !== "AbortError") setError(err);
+    }).finally(() => setLoading(false));
+    return () => controller.abort();
+  }, [path, apiPrefix, accessToken, isAuthenticated]);
+  return { data, loading, error };
+}
+
+// src/client/hooks/useMe.ts
+function useMe() {
+  return useAuthFetch("/me");
+}
+
+// src/client/hooks/useMeTracks.ts
+function useMeTracks() {
+  return useAuthFetch("/me/tracks");
+}
+
+// src/client/hooks/useMeLikes.ts
+function useMeLikes() {
+  return useAuthFetch("/me/likes");
+}
+
+// src/client/hooks/useMePlaylists.ts
+function useMePlaylists() {
+  return useAuthFetch("/me/playlists");
+}
+
+// src/client/hooks/useMeFollowings.ts
+function useMeFollowings() {
+  return useAuthFetch("/me/followings");
+}
+
+// src/client/hooks/useMeFollowers.ts
+function useMeFollowers() {
+  return useAuthFetch("/me/followers");
+}
+
+// src/client/hooks/useFollow.ts
+
+function useFollow() {
+  const { apiPrefix, accessToken } = useSoundCloudContext();
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const follow = _react.useCallback.call(void 0, 
+    async (userId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/me/follow/${userId}`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  const unfollow = _react.useCallback.call(void 0, 
+    async (userId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/me/follow/${userId}`, {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  return { follow, unfollow, loading, error };
+}
+
+// src/client/hooks/useLike.ts
+
+function useLike() {
+  const { apiPrefix, accessToken } = useSoundCloudContext();
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const likeTrack = _react.useCallback.call(void 0, 
+    async (trackId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/tracks/${trackId}/like`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  const unlikeTrack = _react.useCallback.call(void 0, 
+    async (trackId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/tracks/${trackId}/like`, {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  return { likeTrack, unlikeTrack, loading, error };
+}
+
+// src/client/hooks/useRepost.ts
+
+function useRepost() {
+  const { apiPrefix, accessToken } = useSoundCloudContext();
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const repostTrack = _react.useCallback.call(void 0, 
+    async (trackId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/tracks/${trackId}/repost`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  const unrepostTrack = _react.useCallback.call(void 0, 
+    async (trackId) => {
+      if (!accessToken) throw new Error("Not authenticated");
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await fetch(`${apiPrefix}/tracks/${trackId}/repost`, {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiPrefix, accessToken]
+  );
+  return { repostTrack, unrepostTrack, loading, error };
+}
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -667,4 +992,4 @@ function useInfinitePlaylistTracks(playlistId) {
 
 
 
-exports.SoundCloudProvider = SoundCloudProvider; exports.useInfinitePlaylistSearch = useInfinitePlaylistSearch; exports.useInfinitePlaylistTracks = useInfinitePlaylistTracks; exports.useInfiniteTrackComments = useInfiniteTrackComments; exports.useInfiniteTrackSearch = useInfiniteTrackSearch; exports.useInfiniteUserFollowers = useInfiniteUserFollowers; exports.useInfiniteUserFollowings = useInfiniteUserFollowings; exports.useInfiniteUserLikes = useInfiniteUserLikes; exports.useInfiniteUserPlaylists = useInfiniteUserPlaylists; exports.useInfiniteUserSearch = useInfiniteUserSearch; exports.useInfiniteUserTracks = useInfiniteUserTracks; exports.usePlayer = usePlayer; exports.usePlaylist = usePlaylist; exports.usePlaylistSearch = usePlaylistSearch; exports.usePlaylistTracks = usePlaylistTracks; exports.useRelatedTracks = useRelatedTracks; exports.useSoundCloudContext = useSoundCloudContext; exports.useTrack = useTrack; exports.useTrackComments = useTrackComments; exports.useTrackLikes = useTrackLikes; exports.useTrackSearch = useTrackSearch; exports.useUser = useUser; exports.useUserFollowers = useUserFollowers; exports.useUserFollowings = useUserFollowings; exports.useUserLikes = useUserLikes; exports.useUserPlaylists = useUserPlaylists; exports.useUserSearch = useUserSearch; exports.useUserTracks = useUserTracks;
+exports.SoundCloudProvider = SoundCloudProvider; exports.useFollow = useFollow; exports.useInfinitePlaylistSearch = useInfinitePlaylistSearch; exports.useInfinitePlaylistTracks = useInfinitePlaylistTracks; exports.useInfiniteTrackComments = useInfiniteTrackComments; exports.useInfiniteTrackSearch = useInfiniteTrackSearch; exports.useInfiniteUserFollowers = useInfiniteUserFollowers; exports.useInfiniteUserFollowings = useInfiniteUserFollowings; exports.useInfiniteUserLikes = useInfiniteUserLikes; exports.useInfiniteUserPlaylists = useInfiniteUserPlaylists; exports.useInfiniteUserSearch = useInfiniteUserSearch; exports.useInfiniteUserTracks = useInfiniteUserTracks; exports.useLike = useLike; exports.useMe = useMe; exports.useMeFollowers = useMeFollowers; exports.useMeFollowings = useMeFollowings; exports.useMeLikes = useMeLikes; exports.useMePlaylists = useMePlaylists; exports.useMeTracks = useMeTracks; exports.usePlayer = usePlayer; exports.usePlaylist = usePlaylist; exports.usePlaylistSearch = usePlaylistSearch; exports.usePlaylistTracks = usePlaylistTracks; exports.useRelatedTracks = useRelatedTracks; exports.useRepost = useRepost; exports.useSCAuth = useSCAuth; exports.useSoundCloudContext = useSoundCloudContext; exports.useTrack = useTrack; exports.useTrackComments = useTrackComments; exports.useTrackLikes = useTrackLikes; exports.useTrackSearch = useTrackSearch; exports.useUser = useUser; exports.useUserFollowers = useUserFollowers; exports.useUserFollowings = useUserFollowings; exports.useUserLikes = useUserLikes; exports.useUserPlaylists = useUserPlaylists; exports.useUserSearch = useUserSearch; exports.useUserTracks = useUserTracks;

package/dist/index.d.cts

@@ -1,10 +1,23 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { SoundCloudTrack, SoundCloudUser, SoundCloudPlaylist, SoundCloudComment } from 'soundcloud-api-ts';
+import * as soundcloud_api_ts from 'soundcloud-api-ts';
+import { SoundCloudUser, SoundCloudTrack, SoundCloudPlaylist, SoundCloudComment } from 'soundcloud-api-ts';
 export { SoundCloudActivitiesResponse, SoundCloudActivity, SoundCloudComment, SoundCloudMe, SoundCloudPaginatedResponse, SoundCloudPlaylist, SoundCloudStreams, SoundCloudTrack, SoundCloudUser, SoundCloudWebProfile } from 'soundcloud-api-ts';
 
 interface SoundCloudContextValue {
     apiPrefix: string;
+    user: SoundCloudUser | null;
+    accessToken: string | null;
+    isAuthenticated: boolean;
+    authLoading: boolean;
+    login: () => void;
+    logout: () => Promise<void>;
+    /** @internal Called by callback handler to set auth tokens */
+    _setAuth: (auth: {
+        accessToken: string;
+        refreshToken: string;
+        expiresIn: number;
+    }) => void;
 }
 interface SoundCloudProviderProps {
     /** API route prefix (default: "/api/soundcloud") */
@@ -20,6 +33,24 @@ interface SoundCloudRoutesConfig {
     clientId: string;
     /** OAuth client secret */
     clientSecret: string;
+    /** OAuth redirect URI (required for authentication features) */
+    redirectUri?: string;
+}
+/** Token returned from SoundCloud OAuth. */
+interface SoundCloudToken {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type: string;
+    scope: string;
+}
+/** Auth state for the client context. */
+interface AuthState {
+    user: soundcloud_api_ts.SoundCloudUser | null;
+    accessToken: string | null;
+    refreshToken: string | null;
+    isAuthenticated: boolean;
+    expiresAt: number | null;
 }
 /** Standard hook return shape. */
 interface HookResult<T> {
@@ -27,6 +58,12 @@ interface HookResult<T> {
     loading: boolean;
     error: Error | null;
 }
+/** Mutation hook return shape. */
+interface MutationResult<TArgs extends any[] = []> {
+    execute: (...args: TArgs) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+}
 /** Infinite/paginated hook return shape. */
 interface InfiniteResult<T> {
     /** Accumulated items across all fetched pages. */
@@ -114,4 +151,59 @@ declare function useInfiniteTrackComments(trackId: string | number | null): Infi
 
 declare function useInfinitePlaylistTracks(playlistId: string | number | null): InfiniteResult<SoundCloudTrack>;
 
-export { type HookResult, type InfiniteResult, type PlayerState, SoundCloudProvider, type SoundCloudProviderProps, type SoundCloudRoutesConfig, type UseTrackSearchOptions, useInfinitePlaylistSearch, useInfinitePlaylistTracks, useInfiniteTrackComments, useInfiniteTrackSearch, useInfiniteUserFollowers, useInfiniteUserFollowings, useInfiniteUserLikes, useInfiniteUserPlaylists, useInfiniteUserSearch, useInfiniteUserTracks, usePlayer, usePlaylist, usePlaylistSearch, usePlaylistTracks, useRelatedTracks, useSoundCloudContext, useTrack, useTrackComments, useTrackLikes, useTrackSearch, useUser, useUserFollowers, useUserFollowings, useUserLikes, useUserPlaylists, useUserSearch, useUserTracks };
+/**
+ * Hook for SoundCloud OAuth authentication state and actions.
+ */
+declare function useSCAuth(): {
+    user: soundcloud_api_ts.SoundCloudUser | null;
+    isAuthenticated: boolean;
+    loading: boolean;
+    login: () => void;
+    logout: () => Promise<void>;
+    /** Handle OAuth callback — exchange code for tokens */
+    handleCallback(code: string, state: string): Promise<any>;
+};
+
+/** Fetch the current authenticated user's profile. */
+declare function useMe(): HookResult<SoundCloudUser>;
+
+/** Fetch the current authenticated user's tracks. */
+declare function useMeTracks(): HookResult<SoundCloudTrack[]>;
+
+/** Fetch the current authenticated user's liked tracks. */
+declare function useMeLikes(): HookResult<SoundCloudTrack[]>;
+
+/** Fetch the current authenticated user's playlists. */
+declare function useMePlaylists(): HookResult<SoundCloudPlaylist[]>;
+
+/** Fetch who the current authenticated user follows. */
+declare function useMeFollowings(): HookResult<SoundCloudUser[]>;
+
+/** Fetch the current authenticated user's followers. */
+declare function useMeFollowers(): HookResult<SoundCloudUser[]>;
+
+/** Hook for follow/unfollow actions. Requires authentication. */
+declare function useFollow(): {
+    follow: (userId: string | number) => Promise<void>;
+    unfollow: (userId: string | number) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};
+
+/** Hook for like/unlike track actions. Requires authentication. */
+declare function useLike(): {
+    likeTrack: (trackId: string | number) => Promise<void>;
+    unlikeTrack: (trackId: string | number) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};
+
+/** Hook for repost/unrepost track actions. Requires authentication. */
+declare function useRepost(): {
+    repostTrack: (trackId: string | number) => Promise<void>;
+    unrepostTrack: (trackId: string | number) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};
+
+export { type AuthState, type HookResult, type InfiniteResult, type MutationResult, type PlayerState, type SoundCloudContextValue, SoundCloudProvider, type SoundCloudProviderProps, type SoundCloudRoutesConfig, type SoundCloudToken, type UseTrackSearchOptions, useFollow, useInfinitePlaylistSearch, useInfinitePlaylistTracks, useInfiniteTrackComments, useInfiniteTrackSearch, useInfiniteUserFollowers, useInfiniteUserFollowings, useInfiniteUserLikes, useInfiniteUserPlaylists, useInfiniteUserSearch, useInfiniteUserTracks, useLike, useMe, useMeFollowers, useMeFollowings, useMeLikes, useMePlaylists, useMeTracks, usePlayer, usePlaylist, usePlaylistSearch, usePlaylistTracks, useRelatedTracks, useRepost, useSCAuth, useSoundCloudContext, useTrack, useTrackComments, useTrackLikes, useTrackSearch, useUser, useUserFollowers, useUserFollowings, useUserLikes, useUserPlaylists, useUserSearch, useUserTracks };