@rocksky/sdk 0.2.0 → 0.2.1

package/src/namespaces/artist.ts

@@ -5,9 +5,9 @@ import type {
   GetArtistRecentListenersParams,
   GetArtistsParams,
   GetArtistTracksParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type { GetArtistsParams, GetArtistTracksParams };
 export type ArtistListenersParams = GetArtistListenersParams;
@@ -15,52 +15,52 @@ export type ArtistListenersParams = GetArtistListenersParams;
 export class ArtistNamespace {
   constructor(private readonly call: Call) {}
 
-  getArtist<T = unknown>(params: GetArtistParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtist", "GET", {
+  getArtist(params: GetArtistParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtist", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtists<T = unknown>(params: GetArtistsParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtists", "GET", {
+  getArtists(params: GetArtistsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistAlbums<T = unknown>(params: GetArtistAlbumsParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.artist.getArtistAlbums", "GET", {
+  getArtistAlbums(params: GetArtistAlbumsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.artist.getArtistAlbums", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistTracks<T = unknown>(
+  getArtistTracks(
     params: GetArtistTracksParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistTracks", "GET", {
+    return this.call("app.rocksky.artist.getArtistTracks", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistListeners<T = unknown>(
+  getArtistListeners(
     params: GetArtistListenersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistListeners", "GET", {
+    return this.call("app.rocksky.artist.getArtistListeners", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistRecentListeners<T = unknown>(
+  getArtistRecentListeners(
     params: GetArtistRecentListenersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.artist.getArtistRecentListeners", "GET", {
+    return this.call("app.rocksky.artist.getArtistRecentListeners", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/charts.ts

@@ -2,9 +2,9 @@ import type {
   GetScrobblesChartParams,
   GetTopArtistsParams,
   GetTopTracksParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type ScrobblesChartParams = GetScrobblesChartParams;
 export type TopChartParams = GetTopArtistsParams;
@@ -12,25 +12,25 @@ export type TopChartParams = GetTopArtistsParams;
 export class ChartsNamespace {
   constructor(private readonly call: Call) {}
 
-  getScrobblesChart<T = unknown>(
+  getScrobblesChart(
     params: ScrobblesChartParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.charts.getScrobblesChart", "GET", {
+    return this.call("app.rocksky.charts.getScrobblesChart", "GET", {
       params,
       ...opts,
     });
   }
 
-  getTopArtists<T = unknown>(params: GetTopArtistsParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.charts.getTopArtists", "GET", {
+  getTopArtists(params: GetTopArtistsParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.charts.getTopArtists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getTopTracks<T = unknown>(params: GetTopTracksParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.charts.getTopTracks", "GET", {
+  getTopTracks(params: GetTopTracksParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.charts.getTopTracks", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/dropbox.ts

@@ -3,48 +3,48 @@ import type {
   GetFilesParams,
   GetMetadataParams,
   GetTemporaryLinkParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class DropboxNamespace {
   constructor(private readonly call: Call) {}
 
-  getFiles<T = unknown>(
+  getFiles(
     params: GetFilesParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.getFiles", "GET", {
+    return this.call("app.rocksky.dropbox.getFiles", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getMetadata<T = unknown>(params: GetMetadataParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.dropbox.getMetadata", "GET", {
+  getMetadata(params: GetMetadataParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.dropbox.getMetadata", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getTemporaryLink<T = unknown>(
+  getTemporaryLink(
     params: GetTemporaryLinkParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.getTemporaryLink", "GET", {
+    return this.call("app.rocksky.dropbox.getTemporaryLink", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  downloadFile<T = unknown>(
+  downloadFile(
     params: DownloadFileParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.dropbox.downloadFile", "GET", {
+    return this.call("app.rocksky.dropbox.downloadFile", "GET", {
       params,
       requireAuth: true,
       ...opts,

package/src/namespaces/feed.ts

@@ -8,103 +8,103 @@ import type {
   GetRecommendationsParams,
   GetStoriesParams,
   SearchParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type RecommendParams = GetRecommendationsParams;
 
 export class FeedNamespace {
   constructor(private readonly call: Call) {}
 
-  search<T = unknown>(params: SearchParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.feed.search", "GET", {
+  search(params: SearchParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.feed.search", "GET", {
       params,
       ...opts,
     });
   }
 
-  getFeed<T = unknown>(
+  getFeed(
     params: GetFeedParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getFeed", "GET", {
+    return this.call("app.rocksky.feed.getFeed", "GET", {
       params,
       ...opts,
     });
   }
 
-  getFeedGenerators<T = unknown>(
+  getFeedGenerators(
     params: GetFeedGeneratorsParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getFeedGenerators", "GET", {
+    return this.call("app.rocksky.feed.getFeedGenerators", "GET", {
       params,
       ...opts,
     });
   }
 
-  getFeedGenerator<T = unknown>(
+  getFeedGenerator(
     params: GetFeedGeneratorParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getFeedGenerator", "GET", {
+    return this.call("app.rocksky.feed.getFeedGenerator", "GET", {
       params,
       ...opts,
     });
   }
 
-  describeFeedGenerator<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.feed.describeFeedGenerator", "GET", {
+  describeFeedGenerator(opts?: RequestOptions) {
+    return this.call("app.rocksky.feed.describeFeedGenerator", "GET", {
       ...opts,
     });
   }
 
-  getFeedSkeleton<T = unknown>(
+  getFeedSkeleton(
     params: GetFeedSkeletonParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getFeedSkeleton", "GET", {
+    return this.call("app.rocksky.feed.getFeedSkeleton", "GET", {
       params,
       ...opts,
     });
   }
 
-  getRecommendations<T = unknown>(
+  getRecommendations(
     params: GetRecommendationsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getRecommendations", "GET", {
+    return this.call("app.rocksky.feed.getRecommendations", "GET", {
       params,
       ...opts,
     });
   }
 
-  getArtistRecommendations<T = unknown>(
+  getArtistRecommendations(
     params: GetArtistRecommendationsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getArtistRecommendations", "GET", {
+    return this.call("app.rocksky.feed.getArtistRecommendations", "GET", {
       params,
       ...opts,
     });
   }
 
-  getAlbumRecommendations<T = unknown>(
+  getAlbumRecommendations(
     params: GetAlbumRecommendationsParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getAlbumRecommendations", "GET", {
+    return this.call("app.rocksky.feed.getAlbumRecommendations", "GET", {
       params,
       ...opts,
     });
   }
 
-  getStories<T = unknown>(
+  getStories(
     params: GetStoriesParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.feed.getStories", "GET", {
+    return this.call("app.rocksky.feed.getStories", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/googledrive.ts

@@ -2,37 +2,37 @@ import type {
   DownloadFileParams,
   GetFileParams,
   GetFilesParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class GoogleDriveNamespace {
   constructor(private readonly call: Call) {}
 
-  getFile<T = unknown>(params: GetFileParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.googledrive.getFile", "GET", {
+  getFile(params: GetFileParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.googledrive.getFile", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getFiles<T = unknown>(
+  getFiles(
     params: GetFilesParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.googledrive.getFiles", "GET", {
+    return this.call("app.rocksky.googledrive.getFiles", "GET", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  downloadFile<T = unknown>(
+  downloadFile(
     params: DownloadFileParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.googledrive.downloadFile", "GET", {
+    return this.call("app.rocksky.googledrive.downloadFile", "GET", {
       params,
       requireAuth: true,
       ...opts,

package/src/namespaces/graph.ts

@@ -4,9 +4,9 @@ import type {
   GetFollowsParams,
   GetKnownFollowersParams,
   UnfollowAccountParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type FollowListParams = GetFollowersParams;
 export type KnownFollowersParams = GetKnownFollowersParams;
@@ -14,47 +14,47 @@ export type KnownFollowersParams = GetKnownFollowersParams;
 export class GraphNamespace {
   constructor(private readonly call: Call) {}
 
-  followAccount<T = unknown>(
+  followAccount(
     params: FollowAccountParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.graph.followAccount", "POST", {
+    return this.call("app.rocksky.graph.followAccount", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  unfollowAccount<T = unknown>(
+  unfollowAccount(
     params: UnfollowAccountParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.graph.unfollowAccount", "POST", {
+    return this.call("app.rocksky.graph.unfollowAccount", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  getFollowers<T = unknown>(params: GetFollowersParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.graph.getFollowers", "GET", {
+  getFollowers(params: GetFollowersParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.graph.getFollowers", "GET", {
       params,
       ...opts,
     });
   }
 
-  getFollows<T = unknown>(params: GetFollowsParams, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.graph.getFollows", "GET", {
+  getFollows(params: GetFollowsParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.graph.getFollows", "GET", {
       params,
       ...opts,
     });
   }
 
-  getKnownFollowers<T = unknown>(
+  getKnownFollowers(
     params: GetKnownFollowersParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.graph.getKnownFollowers", "GET", {
+    return this.call("app.rocksky.graph.getKnownFollowers", "GET", {
       params,
       ...opts,
     });

package/src/namespaces/like.ts

@@ -3,41 +3,41 @@ import type {
   DislikeSongInput,
   LikeShoutInput,
   LikeSongInput,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type LikeInput = LikeSongInput;
 
 export class LikeNamespace {
   constructor(private readonly call: Call) {}
 
-  likeSong<T = unknown>(input: LikeSongInput = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.like.likeSong", "POST", {
+  likeSong(input: LikeSongInput = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.like.likeSong", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  dislikeSong<T = unknown>(input: DislikeSongInput = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.like.dislikeSong", "POST", {
+  dislikeSong(input: DislikeSongInput = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.like.dislikeSong", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  likeShout<T = unknown>(input: LikeShoutInput = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.like.likeShout", "POST", {
+  likeShout(input: LikeShoutInput = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.like.likeShout", "POST", {
       body: input,
       requireAuth: true,
       ...opts,
     });
   }
 
-  dislikeShout<T = unknown>(input: DislikeShoutInput = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.like.dislikeShout", "POST", {
+  dislikeShout(input: DislikeShoutInput = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.like.dislikeShout", "POST", {
       body: input,
       requireAuth: true,
       ...opts,

package/src/namespaces/mirror.ts

@@ -1,24 +1,24 @@
-import type { PutMirrorSourceInput } from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+import type { PutMirrorSourceInput } from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export type { PutMirrorSourceInput };
 
 export class MirrorNamespace {
   constructor(private readonly call: Call) {}
 
-  getMirrorSources<T = unknown>(opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.mirror.getMirrorSources", "GET", {
+  getMirrorSources(opts?: RequestOptions) {
+    return this.call("app.rocksky.mirror.getMirrorSources", "GET", {
       requireAuth: true,
       ...opts,
     });
   }
 
-  putMirrorSource<T = unknown>(
+  putMirrorSource(
     input: PutMirrorSourceInput,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.mirror.putMirrorSource", "POST", {
+    return this.call("app.rocksky.mirror.putMirrorSource", "POST", {
       body: input,
       requireAuth: true,
       ...opts,

package/src/namespaces/player.ts

@@ -10,114 +10,114 @@ import type {
   PlayParams,
   PreviousParams,
   SeekParams,
-} from "../generated/types";
-import type { RequestOptions } from "../types";
-import type { Call } from "./_helpers";
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class PlayerNamespace {
   constructor(private readonly call: Call) {}
 
-  getCurrentlyPlaying<T = unknown>(
+  getCurrentlyPlaying(
     params: GetCurrentlyPlayingParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.getCurrentlyPlaying", "GET", {
+    return this.call("app.rocksky.player.getCurrentlyPlaying", "GET", {
       params,
       ...opts,
     });
   }
 
-  getPlaybackQueue<T = unknown>(
+  getPlaybackQueue(
     params: GetPlaybackQueueParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.getPlaybackQueue", "GET", {
+    return this.call("app.rocksky.player.getPlaybackQueue", "GET", {
       params,
       ...opts,
     });
   }
 
-  play<T = unknown>(params: PlayParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.player.play", "POST", {
+  play(params: PlayParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.player.play", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  pause<T = unknown>(params: PauseParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.player.pause", "POST", {
+  pause(params: PauseParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.player.pause", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  next<T = unknown>(params: NextParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.player.next", "POST", {
+  next(params: NextParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.player.next", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  previous<T = unknown>(params: PreviousParams = {}, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.player.previous", "POST", {
+  previous(params: PreviousParams = {}, opts?: RequestOptions) {
+    return this.call("app.rocksky.player.previous", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  seek<T = unknown>(
+  seek(
     params: SeekParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.seek", "POST", {
+    return this.call("app.rocksky.player.seek", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  playFile<T = unknown>(
+  playFile(
     params: PlayFileParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.playFile", "POST", {
+    return this.call("app.rocksky.player.playFile", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  playDirectory<T = unknown>(
+  playDirectory(
     params: PlayDirectoryParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.playDirectory", "POST", {
+    return this.call("app.rocksky.player.playDirectory", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  addItemsToQueue<T = unknown>(
+  addItemsToQueue(
     params: AddItemsToQueueParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.addItemsToQueue", "POST", {
+    return this.call("app.rocksky.player.addItemsToQueue", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  addDirectoryToQueue<T = unknown>(
+  addDirectoryToQueue(
     params: AddDirectoryToQueueParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.addDirectoryToQueue", "POST", {
+    return this.call("app.rocksky.player.addDirectoryToQueue", "POST", {
       params,
       ...opts,
     });