@rocksky/sdk 0.1.0 → 0.2.1

package/src/namespaces/feed.ts

@@ -1,104 +1,110 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  GetAlbumRecommendationsParams,
+  GetArtistRecommendationsParams,
+  GetFeedGeneratorParams,
+  GetFeedGeneratorsParams,
+  GetFeedParams,
+  GetFeedSkeletonParams,
+  GetRecommendationsParams,
+  GetStoriesParams,
+  SearchParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type RecommendParams = { did: string; limit?: number };
+export type RecommendParams = GetRecommendationsParams;
 
 export class FeedNamespace {
   constructor(private readonly call: Call) {}
 
-  search<T = unknown>(params: { query: string }, 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>(
-    params: { feed: string; limit?: number; cursor?: string },
+  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>(
-    params: { size?: number } = {},
+  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>(
-    params: { feed: string },
+  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>(
-    params: {
-      feed: string;
-      limit?: number;
-      offset?: number;
-      cursor?: string;
-    },
+  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>(
-    params: RecommendParams,
+  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>(
-    params: RecommendParams,
+  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>(
-    params: RecommendParams,
+  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>(
-    params: { size?: number } = {},
+  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

@@ -1,33 +1,38 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  DownloadFileParams,
+  GetFileParams,
+  GetFilesParams,
+} 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: { fileId: string }, 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>(
-    params: { at?: string } = {},
+  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>(
-    params: { fileId: string },
+  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

@@ -1,61 +1,60 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  FollowAccountParams,
+  GetFollowersParams,
+  GetFollowsParams,
+  GetKnownFollowersParams,
+  UnfollowAccountParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type ActorParam = { actor: string };
-export type FollowListParams = ActorParam & {
-  limit?: number;
-  cursor?: string;
-  dids?: string[];
-};
-export type KnownFollowersParams = ActorParam & {
-  limit?: number;
-  cursor?: string;
-};
+export type FollowListParams = GetFollowersParams;
+export type KnownFollowersParams = GetKnownFollowersParams;
 
 export class GraphNamespace {
   constructor(private readonly call: Call) {}
 
-  followAccount<T = unknown>(
-    params: { account: string },
+  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>(
-    params: { account: string },
+  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: FollowListParams, 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: FollowListParams, 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>(
-    params: KnownFollowersParams,
+  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

@@ -1,37 +1,43 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  DislikeShoutInput,
+  DislikeSongInput,
+  LikeShoutInput,
+  LikeSongInput,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type LikeInput = { uri?: string };
+export type LikeInput = LikeSongInput;
 
 export class LikeNamespace {
   constructor(private readonly call: Call) {}
 
-  likeSong<T = unknown>(input: LikeInput = {}, 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: LikeInput = {}, 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: LikeInput = {}, 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: LikeInput = {}, 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,28 +1,24 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type { PutMirrorSourceInput } from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
-export type PutMirrorSourceInput = {
-  provider: string;
-  enabled?: boolean;
-  externalUsername?: string;
-  apiKey?: string;
-};
+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

@@ -1,125 +1,123 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
-
-type PlayerId = { playerId?: string };
+import type {
+  AddDirectoryToQueueParams,
+  AddItemsToQueueParams,
+  GetCurrentlyPlayingParams,
+  GetPlaybackQueueParams,
+  NextParams,
+  PauseParams,
+  PlayDirectoryParams,
+  PlayFileParams,
+  PlayParams,
+  PreviousParams,
+  SeekParams,
+} 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>(
-    params: PlayerId & { actor?: string } = {},
+  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>(
-    params: PlayerId = {},
+  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: PlayerId = {}, 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: PlayerId = {}, 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: PlayerId = {}, 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: PlayerId = {}, 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>(
-    params: PlayerId & { position: number },
+  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>(
-    params: PlayerId & { fileId: string },
+  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>(
-    params: PlayerId & {
-      directoryId: string;
-      shuffle?: boolean;
-      recurse?: boolean;
-      position?: number;
-    },
+  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>(
-    params: PlayerId & {
-      items: string[];
-      position?: number;
-      shuffle?: boolean;
-    },
+  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>(
-    params: PlayerId & {
-      directory: string;
-      position?: number;
-      shuffle?: boolean;
-    },
+  addDirectoryToQueue(
+    params: AddDirectoryToQueueParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.player.addDirectoryToQueue", "POST", {
+    return this.call("app.rocksky.player.addDirectoryToQueue", "POST", {
       params,
       ...opts,
     });

package/src/namespaces/playlist.ts

@@ -1,83 +1,93 @@
-import type { Call } from "./_helpers";
-import type { RequestOptions } from "../types";
+import type {
+  CreatePlaylistParams,
+  GetPlaylistParams,
+  GetPlaylistsParams,
+  InsertDirectoryParams,
+  InsertFilesParams,
+  RemovePlaylistParams,
+  RemoveTrackParams,
+  StartPlaylistParams,
+} from "../generated/types.js";
+import type { RequestOptions } from "../types.js";
+import type { Call } from "./_helpers.js";
 
 export class PlaylistNamespace {
   constructor(private readonly call: Call) {}
 
-  getPlaylists<T = unknown>(
-    params: { limit?: number; offset?: number } = {},
+  getPlaylists(
+    params: GetPlaylistsParams = {},
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.getPlaylists", "GET", {
+    return this.call("app.rocksky.playlist.getPlaylists", "GET", {
       params,
       ...opts,
     });
   }
 
-  getPlaylist<T = unknown>(params: { uri: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.playlist.getPlaylist", "GET", {
+  getPlaylist(params: GetPlaylistParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.playlist.getPlaylist", "GET", {
       params,
       ...opts,
     });
   }
 
-  createPlaylist<T = unknown>(
-    params: { name: string; description?: string },
+  createPlaylist(
+    params: CreatePlaylistParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.createPlaylist", "POST", {
+    return this.call("app.rocksky.playlist.createPlaylist", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  removePlaylist<T = unknown>(params: { uri: string }, opts?: RequestOptions) {
-    return this.call<T>("app.rocksky.playlist.removePlaylist", "POST", {
+  removePlaylist(params: RemovePlaylistParams, opts?: RequestOptions) {
+    return this.call("app.rocksky.playlist.removePlaylist", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  startPlaylist<T = unknown>(
-    params: { uri: string; shuffle?: boolean; position?: number },
+  startPlaylist(
+    params: StartPlaylistParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.startPlaylist", "POST", {
+    return this.call("app.rocksky.playlist.startPlaylist", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  insertDirectory<T = unknown>(
-    params: { uri: string; directory: string; position?: number },
+  insertDirectory(
+    params: InsertDirectoryParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.insertDirectory", "POST", {
+    return this.call("app.rocksky.playlist.insertDirectory", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  insertFiles<T = unknown>(
-    params: { uri: string; files: string[]; position?: number },
+  insertFiles(
+    params: InsertFilesParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.insertFiles", "POST", {
+    return this.call("app.rocksky.playlist.insertFiles", "POST", {
       params,
       requireAuth: true,
       ...opts,
     });
   }
 
-  removeTrack<T = unknown>(
-    params: { uri: string; position: number },
+  removeTrack(
+    params: RemoveTrackParams,
     opts?: RequestOptions,
   ) {
-    return this.call<T>("app.rocksky.playlist.removeTrack", "POST", {
+    return this.call("app.rocksky.playlist.removeTrack", "POST", {
       params,
       ...opts,
     });