@rocksky/sdk 0.1.0 → 0.2.1

package/src/namespaces/scrobble.ts

@@ -1,65 +1,39 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  CreateScrobbleInput,
+  GetScrobbleParams,
+  GetScrobblesParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type CreateScrobbleInput = {
-  title: string;
-  artist: string;
-  album?: string;
-  duration?: number;
-  mbId?: string;
-  isrc?: string;
-  albumArt?: string;
-  trackNumber?: number;
-  releaseDate?: string;
-  year?: number;
-  discNumber?: number;
-  lyrics?: string;
-  composer?: string;
-  copyrightMessage?: string;
-  label?: string;
-  artistPicture?: string;
-  spotifyLink?: string;
-  lastfmLink?: string;
-  tidalLink?: string;
-  appleMusicLink?: string;
-  youtubeLink?: string;
-  deezerLink?: string;
-  timestamp?: number;
-};
-
-export type GetScrobblesParams = {
-  did?: string;
-  following?: boolean;
-  limit?: number;
-  offset?: number;
-};
+export type { CreateScrobbleInput, GetScrobblesParams };
 
 export class ScrobbleNamespace {
   constructor(private readonly call: Call) {}
 
-  createScrobble<T = unknown>(
+  createScrobble(
     input: CreateScrobbleInput,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.scrobble.createScrobble", "POST", {
+    return this.call("app.rocksky.scrobble.createScrobble", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getScrobble<T = unknown>(params: { uri: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.scrobble.getScrobble", "GET", {
+  getScrobble(params: GetScrobbleParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.scrobble.getScrobble", "GET", {
       params,
       ...opts,
     });
   }
 
-  getScrobbles<T = unknown>(
+  getScrobbles(
     params: GetScrobblesParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.scrobble.getScrobbles", "GET", {
+    return this.call("app.rocksky.scrobble.getScrobbles", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/shout.ts

@@ -1,88 +1,97 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
-
-type UriPage = { uri: string; limit?: number; offset?: number };
+import type {
+  CreateShoutInput,
+  GetAlbumShoutsParams,
+  GetArtistShoutsParams,
+  GetProfileShoutsParams,
+  GetShoutRepliesParams,
+  GetTrackShoutsParams,
+  RemoveShoutParams,
+  ReplyShoutInput,
+  ReportShoutInput,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class ShoutNamespace {
   constructor(private readonly call: Call) {}
 
-  createShout<T = unknown>(
-    input: { message?: string } = {},
+  createShout(
+    input: CreateShoutInput = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.shout.createShout", "POST", {
+    return this.call("app.rocksky.shout.createShout", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  replyShout<T = unknown>(
-    input: { shoutId: string; message: string },
+  replyShout(
+    input: ReplyShoutInput,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.shout.replyShout", "POST", {
+    return this.call("app.rocksky.shout.replyShout", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  reportShout<T = unknown>(
-    input: { shoutId: string; reason?: string },
+  reportShout(
+    input: ReportShoutInput,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.shout.reportShout", "POST", {
+    return this.call("app.rocksky.shout.reportShout", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  removeShout<T = unknown>(params: { id: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.shout.removeShout", "POST", {
+  removeShout(params: RemoveShoutParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.shout.removeShout", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getShoutReplies<T = unknown>(params: UriPage, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.shout.getShoutReplies", "GET", {
+  getShoutReplies(params: GetShoutRepliesParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.shout.getShoutReplies", "GET", {
       params,
       ...opts,
     });
   }
 
-  getProfileShouts<T = unknown>(
-    params: { did: string; limit?: number; offset?: number },
+  getProfileShouts(
+    params: GetProfileShoutsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.shout.getProfileShouts", "GET", {
+    return this.call("app.rocksky.shout.getProfileShouts", "GET", {
       params,
       ...opts,
     });
   }
 
-  getTrackShouts<T = unknown>(
-    params: { uri: string },
+  getTrackShouts(
+    params: GetTrackShoutsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.shout.getTrackShouts", "GET", {
+    return this.call("app.rocksky.shout.getTrackShouts", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistShouts<T = unknown>(params: UriPage, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.shout.getArtistShouts", "GET", {
+  getArtistShouts(params: GetArtistShoutsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.shout.getArtistShouts", "GET", {
       params,
       ...opts,
     });
   }
 
-  getAlbumShouts<T = unknown>(params: UriPage, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.shout.getAlbumShouts", "GET", {
+  getAlbumShouts(params: GetAlbumShoutsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.shout.getAlbumShouts", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/song.ts

@@ -1,78 +1,57 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
-
-export type GetSongParams = {
-  uri?: string;
-  mbid?: string;
-  isrc?: string;
-  spotifyId?: string;
-};
-
-export type GetSongsParams = GetSongParams & {
-  limit?: number;
-  offset?: number;
-  genre?: string;
-};
-
-export type MatchSongParams = {
-  title: string;
-  artist: string;
-  mbId?: string;
-  isrc?: string;
-};
-
-export type CreateSongInput = {
-  title: string;
-  artist: string;
-  albumArtist: string;
-  album: string;
-  duration?: number;
-  mbId?: string;
-  isrc?: string;
-  albumArt?: string;
-  trackNumber?: number;
-  releaseDate?: string;
-  year?: number;
-  discNumber?: number;
-  lyrics?: string;
+import type {
+  CreateSongInput,
+  GetSongParams,
+  GetSongRecentListenersParams,
+  GetSongsParams,
+  MatchSongParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
+
+export type {
+  CreateSongInput,
+  GetSongParams,
+  GetSongRecentListenersParams,
+  GetSongsParams,
+  MatchSongParams,
 };
 
 export class SongNamespace {
   constructor(private readonly call: Call) {}
 
-  getSong<T = unknown>(params: GetSongParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.song.getSong", "GET", {
+  getSong(params: GetSongParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.song.getSong", "GET", {
       params,
       ...opts,
     });
   }
 
-  getSongs<T = unknown>(params: GetSongsParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.song.getSongs", "GET", {
+  getSongs(params: GetSongsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.song.getSongs", "GET", {
       params,
       ...opts,
     });
   }
 
-  getSongRecentListeners<T = unknown>(
-    params: { uri: string; limit?: number; offset?: number },
+  getSongRecentListeners(
+    params: GetSongRecentListenersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.song.getSongRecentListeners", "GET", {
+    return this.call("app.rocksky.song.getSongRecentListeners", "GET", {
       params,
       ...opts,
     });
   }
 
-  matchSong<T = unknown>(params: MatchSongParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.song.matchSong", "GET", {
+  matchSong(params: MatchSongParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.song.matchSong", "GET", {
       params,
       ...opts,
     });
   }
 
-  createSong<T = unknown>(input: CreateSongInput, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.song.createSong", "POST", {
+  createSong(input: CreateSongInput, opts?: RequestOptions) {
+    return this.call("app.rocksky.song.createSong", "POST", {
       body: input,
       requireAuth: true,
       ...opts,

package/src/namespaces/spotify.ts

@@ -1,49 +1,53 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetCurrentlyPlayingParams,
+  SeekParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class SpotifyNamespace {
   constructor(private readonly call: Call) {}
 
-  getCurrentlyPlaying<T = unknown>(
-    params: { actor?: string } = {},
+  getCurrentlyPlaying(
+    params: GetCurrentlyPlayingParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.spotify.getCurrentlyPlaying", "GET", {
+    return this.call("app.rocksky.spotify.getCurrentlyPlaying", "GET", {
       params,
       ...opts,
     });
   }
 
-  play<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.spotify.play", "POST", {
+  play(opts?: RequestOptions) {
+    return this.call("app.rocksky.spotify.play", "POST", {
       requireAuth: true,
       ...opts,
     });
   }
 
-  pause<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.spotify.pause", "POST", {
+  pause(opts?: RequestOptions) {
+    return this.call("app.rocksky.spotify.pause", "POST", {
       requireAuth: true,
       ...opts,
     });
   }
 
-  next<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.spotify.next", "POST", {
+  next(opts?: RequestOptions) {
+    return this.call("app.rocksky.spotify.next", "POST", {
       requireAuth: true,
       ...opts,
     });
   }
 
-  previous<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.spotify.previous", "POST", {
+  previous(opts?: RequestOptions) {
+    return this.call("app.rocksky.spotify.previous", "POST", {
       requireAuth: true,
       ...opts,
     });
   }
 
-  seek<T = unknown>(params: { position: number }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.spotify.seek", "POST", {
+  seek(params: SeekParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.spotify.seek", "POST", {
       params,
       requireAuth: true,
       ...opts,

package/src/namespaces/stats.ts

@@ -1,21 +1,25 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetStatsParams,
+  GetWrappedParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class StatsNamespace {
   constructor(private readonly call: Call) {}
 
-  getStats<T = unknown>(params: { did: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.stats.getStats", "GET", {
+  getStats(params: GetStatsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.stats.getStats", "GET", {
       params,
       ...opts,
     });
   }
 
-  getWrapped<T = unknown>(
-    params: { did: string; year?: number },
+  getWrapped(
+    params: GetWrappedParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.stats.getWrapped", "GET", {
+    return this.call("app.rocksky.stats.getWrapped", "GET", {
       params,
       ...opts,
     });

package/src/pipe.ts

@@ -1,4 +1,4 @@
-import { RockskyTimeoutError } from "./errors";
+import { RockskyTimeoutError } from "./errors.js";
 
 /**
  * Compose async operators.

package/src/realtime.ts

@@ -1,5 +1,5 @@
-import { RockskyError } from "./errors";
-import { DEFAULT_BASE_URL } from "./types";
+import { RockskyError } from "./errors.js";
+import { DEFAULT_BASE_URL } from "./types.js";
 
 /** Minimal WebSocket interface — works with browser `WebSocket`, `ws`, `bun`. */
 export interface WebSocketLike {