@rocksky/sdk 0.1.0

package/src/namespaces/feed.ts

@@ -0,0 +1,106 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+export type RecommendParams = { did: string; limit?: number };
+
+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", {
+      params,
+      ...opts,
+    });
+  }
+
+  getFeed<T = unknown>(
+    params: { feed: string; limit?: number; cursor?: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getFeed", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getFeedGenerators<T = unknown>(
+    params: { size?: number } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getFeedGenerators", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getFeedGenerator<T = unknown>(
+    params: { feed: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getFeedGenerator", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  describeFeedGenerator<T = unknown>(opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.feed.describeFeedGenerator", "GET", {
+      ...opts,
+    });
+  }
+
+  getFeedSkeleton<T = unknown>(
+    params: {
+      feed: string;
+      limit?: number;
+      offset?: number;
+      cursor?: string;
+    },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getFeedSkeleton", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getRecommendations<T = unknown>(
+    params: RecommendParams,
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getRecommendations", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getArtistRecommendations<T = unknown>(
+    params: RecommendParams,
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getArtistRecommendations", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getAlbumRecommendations<T = unknown>(
+    params: RecommendParams,
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getAlbumRecommendations", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getStories<T = unknown>(
+    params: { size?: number } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.feed.getStories", "GET", {
+      params,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/googledrive.ts

@@ -0,0 +1,36 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+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", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  getFiles<T = unknown>(
+    params: { at?: string } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.googledrive.getFiles", "GET", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  downloadFile<T = unknown>(
+    params: { fileId: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.googledrive.downloadFile", "GET", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/graph.ts

@@ -0,0 +1,63 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+export type ActorParam = { actor: string };
+export type FollowListParams = ActorParam & {
+  limit?: number;
+  cursor?: string;
+  dids?: string[];
+};
+export type KnownFollowersParams = ActorParam & {
+  limit?: number;
+  cursor?: string;
+};
+
+export class GraphNamespace {
+  constructor(private readonly call: Call) {}
+
+  followAccount<T = unknown>(
+    params: { account: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.graph.followAccount", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  unfollowAccount<T = unknown>(
+    params: { account: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("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", {
+      params,
+      ...opts,
+    });
+  }
+
+  getFollows<T = unknown>(params: FollowListParams, opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.graph.getFollows", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getKnownFollowers<T = unknown>(
+    params: KnownFollowersParams,
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.graph.getKnownFollowers", "GET", {
+      params,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/like.ts

@@ -0,0 +1,40 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+export type LikeInput = { uri?: string };
+
+export class LikeNamespace {
+  constructor(private readonly call: Call) {}
+
+  likeSong<T = unknown>(input: LikeInput = {}, opts?: RequestOptions) {
+    return this.call<T>("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", {
+      body: input,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  likeShout<T = unknown>(input: LikeInput = {}, opts?: RequestOptions) {
+    return this.call<T>("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", {
+      body: input,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/mirror.ts

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

package/src/namespaces/player.ts

@@ -0,0 +1,127 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+type PlayerId = { playerId?: string };
+
+export class PlayerNamespace {
+  constructor(private readonly call: Call) {}
+
+  getCurrentlyPlaying<T = unknown>(
+    params: PlayerId & { actor?: string } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.getCurrentlyPlaying", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getPlaybackQueue<T = unknown>(
+    params: PlayerId = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.getPlaybackQueue", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  play<T = unknown>(params: PlayerId = {}, opts?: RequestOptions) {
+    return this.call<T>("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", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  next<T = unknown>(params: PlayerId = {}, opts?: RequestOptions) {
+    return this.call<T>("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", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  seek<T = unknown>(
+    params: PlayerId & { position: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.seek", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  playFile<T = unknown>(
+    params: PlayerId & { fileId: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.playFile", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  playDirectory<T = unknown>(
+    params: PlayerId & {
+      directoryId: string;
+      shuffle?: boolean;
+      recurse?: boolean;
+      position?: number;
+    },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.playDirectory", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  addItemsToQueue<T = unknown>(
+    params: PlayerId & {
+      items: string[];
+      position?: number;
+      shuffle?: boolean;
+    },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.addItemsToQueue", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  addDirectoryToQueue<T = unknown>(
+    params: PlayerId & {
+      directory: string;
+      position?: number;
+      shuffle?: boolean;
+    },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.player.addDirectoryToQueue", "POST", {
+      params,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/playlist.ts

@@ -0,0 +1,85 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+export class PlaylistNamespace {
+  constructor(private readonly call: Call) {}
+
+  getPlaylists<T = unknown>(
+    params: { limit?: number; offset?: number } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.playlist.getPlaylists", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getPlaylist<T = unknown>(params: { uri: string }, opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.playlist.getPlaylist", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  createPlaylist<T = unknown>(
+    params: { name: string; description?: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("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", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  startPlaylist<T = unknown>(
+    params: { uri: string; shuffle?: boolean; position?: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.playlist.startPlaylist", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  insertDirectory<T = unknown>(
+    params: { uri: string; directory: string; position?: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.playlist.insertDirectory", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  insertFiles<T = unknown>(
+    params: { uri: string; files: string[]; position?: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.playlist.insertFiles", "POST", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  removeTrack<T = unknown>(
+    params: { uri: string; position: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.playlist.removeTrack", "POST", {
+      params,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/scrobble.ts

@@ -0,0 +1,67 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+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 class ScrobbleNamespace {
+  constructor(private readonly call: Call) {}
+
+  createScrobble<T = unknown>(
+    input: CreateScrobbleInput,
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("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", {
+      params,
+      ...opts,
+    });
+  }
+
+  getScrobbles<T = unknown>(
+    params: GetScrobblesParams = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.scrobble.getScrobbles", "GET", {
+      params,
+      ...opts,
+    });
+  }
+}

package/src/namespaces/shout.ts

@@ -0,0 +1,90 @@
+import type { Call } from "./_helpers";
+import type { RequestOptions } from "../types";
+
+type UriPage = { uri: string; limit?: number; offset?: number };
+
+export class ShoutNamespace {
+  constructor(private readonly call: Call) {}
+
+  createShout<T = unknown>(
+    input: { message?: string } = {},
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.shout.createShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  replyShout<T = unknown>(
+    input: { shoutId: string; message: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.shout.replyShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  reportShout<T = unknown>(
+    input: { shoutId: string; reason?: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("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", {
+      params,
+      requireAuth: true,
+      ...opts,
+    });
+  }
+
+  getShoutReplies<T = unknown>(params: UriPage, opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.shout.getShoutReplies", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getProfileShouts<T = unknown>(
+    params: { did: string; limit?: number; offset?: number },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.shout.getProfileShouts", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getTrackShouts<T = unknown>(
+    params: { uri: string },
+    opts?: RequestOptions,
+  ) {
+    return this.call<T>("app.rocksky.shout.getTrackShouts", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getArtistShouts<T = unknown>(params: UriPage, opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.shout.getArtistShouts", "GET", {
+      params,
+      ...opts,
+    });
+  }
+
+  getAlbumShouts<T = unknown>(params: UriPage, opts?: RequestOptions) {
+    return this.call<T>("app.rocksky.shout.getAlbumShouts", "GET", {
+      params,
+      ...opts,
+    });
+  }
+}