+5

apps/api/lexicons/album/album.json

··· 53 53 ], 54 54 "maxSize": 2000000 55 55 }, 56 56 + "albumArtUrl": { 57 57 + "type": "string", 58 58 + "description": "The URL of the album art of the album.", 59 59 + "format": "uri" 60 60 + }, 56 61 "tags": { 57 62 "type": "array", 58 63 "description": "The tags of the album.",

+5

apps/api/lexicons/artist/artist.json

··· 33 33 ], 34 34 "maxSize": 2000000 35 35 }, 36 36 + "pictureUrl": { 37 37 + "type": "string", 38 38 + "description": "The URL of the picture of the artist.", 39 39 + "format": "uri" 40 40 + }, 36 41 "tags": { 37 42 "type": "array", 38 43 "description": "The tags of the artist.",

+5

apps/api/lexicons/scrobble/scrobble.json

··· 108 108 ], 109 109 "maxSize": 2000000 110 110 }, 111 111 + "albumArtUrl": { 112 112 + "type": "string", 113 113 + "description": "The URL of the album art of the song.", 114 114 + "format": "uri" 115 115 + }, 111 116 "youtubeLink": { 112 117 "type": "string", 113 118 "description": "The YouTube link of the song.",

+5

apps/api/lexicons/song/song.json

··· 109 109 ], 110 110 "maxSize": 2000000 111 111 }, 112 112 + "albumArtUrl": { 113 113 + "type": "string", 114 114 + "description": "The URL of the album art of the song.", 115 115 + "format": "uri" 116 116 + }, 112 117 "youtubeLink": { 113 118 "type": "string", 114 119 "description": "The YouTube link of the song.",

+6

apps/api/pkl/defs/album/album.pkl

··· 54 54 maxSize = 2000000 55 55 } 56 56 57 57 + ["albumArtUrl"] = new StringType { 58 58 + type = "string" 59 59 + description = "The URL of the album art of the album." 60 60 + format = "uri" 61 61 + } 62 62 + 57 63 ["tags"] = new Array { 58 64 type = "array" 59 65 description = "The tags of the album."

+6

apps/api/pkl/defs/artist/artist.pkl

··· 31 31 maxSize = 2000000 32 32 } 33 33 34 34 + ["pictureUrl"] = new StringType { 35 35 + type = "string" 36 36 + description = "The URL of the picture of the artist." 37 37 + format = "uri" 38 38 + } 39 39 + 34 40 ["tags"] = new Array { 35 41 type = "array" 36 42 description = "The tags of the artist."

+6

apps/api/pkl/defs/scrobble/scrobble.pkl

··· 115 115 maxSize = 2000000 116 116 } 117 117 118 118 + ["albumArtUrl"] = new StringType { 119 119 + type = "string" 120 120 + description = "The URL of the album art of the song." 121 121 + format = "uri" 122 122 + } 123 123 + 118 124 ["youtubeLink"] = new StringType { 119 125 type = "string" 120 126 description = "The YouTube link of the song."

+6

apps/api/pkl/defs/song/song.pkl

··· 116 116 maxSize = 2000000 117 117 } 118 118 119 119 + ["albumArtUrl"] = new StringType { 120 120 + type = "string" 121 121 + description = "The URL of the album art of the song." 122 122 + format = "uri" 123 123 + } 124 124 + 119 125 ["youtubeLink"] = new StringType { 120 126 type = "string" 121 127 description = "The YouTube link of the song."

+1 -1

apps/api/src/bsky/app.ts

··· 77 77 ? Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365 * 1000 78 78 : Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, 79 79 }, 80 80 - env.JWT_SECRET 80 80 + env.JWT_SECRET, 81 81 ); 82 82 ctx.kv.set(did, token); 83 83 } catch (err) {

+340 -340

apps/api/src/lexicon/index.ts

··· 3 3 */ 4 4 import { 5 5 createServer as createXrpcServer, 6 6 - type Server as XrpcServer, 7 7 - type Options as XrpcOptions, 8 8 - type AuthVerifier, 9 9 - type StreamAuthVerifier, 10 10 - } from '@atproto/xrpc-server' 11 11 - import { schemas } from './lexicons' 12 12 - import type * as AppRockskyActorGetActorAlbums from './types/app/rocksky/actor/getActorAlbums' 13 13 - import type * as AppRockskyActorGetActorArtists from './types/app/rocksky/actor/getActorArtists' 14 14 - import type * as AppRockskyActorGetActorLovedSongs from './types/app/rocksky/actor/getActorLovedSongs' 15 15 - import type * as AppRockskyActorGetActorPlaylists from './types/app/rocksky/actor/getActorPlaylists' 16 16 - import type * as AppRockskyActorGetActorScrobbles from './types/app/rocksky/actor/getActorScrobbles' 17 17 - import type * as AppRockskyActorGetActorSongs from './types/app/rocksky/actor/getActorSongs' 18 18 - import type * as AppRockskyActorGetProfile from './types/app/rocksky/actor/getProfile' 19 19 - import type * as AppRockskyAlbumGetAlbum from './types/app/rocksky/album/getAlbum' 20 20 - import type * as AppRockskyAlbumGetAlbums from './types/app/rocksky/album/getAlbums' 21 21 - import type * as AppRockskyAlbumGetAlbumTracks from './types/app/rocksky/album/getAlbumTracks' 22 22 - import type * as AppRockskyApikeyCreateApikey from './types/app/rocksky/apikey/createApikey' 23 23 - import type * as AppRockskyApikeyGetApikeys from './types/app/rocksky/apikey/getApikeys' 24 24 - import type * as AppRockskyApikeyRemoveApikey from './types/app/rocksky/apikey/removeApikey' 25 25 - import type * as AppRockskyApikeyUpdateApikey from './types/app/rocksky/apikey/updateApikey' 26 26 - import type * as AppRockskyArtistGetArtistAlbums from './types/app/rocksky/artist/getArtistAlbums' 27 27 - import type * as AppRockskyArtistGetArtist from './types/app/rocksky/artist/getArtist' 28 28 - import type * as AppRockskyArtistGetArtistListeners from './types/app/rocksky/artist/getArtistListeners' 29 29 - import type * as AppRockskyArtistGetArtists from './types/app/rocksky/artist/getArtists' 30 30 - import type * as AppRockskyArtistGetArtistTracks from './types/app/rocksky/artist/getArtistTracks' 31 31 - import type * as AppRockskyChartsGetScrobblesChart from './types/app/rocksky/charts/getScrobblesChart' 32 32 - import type * as AppRockskyDropboxDownloadFile from './types/app/rocksky/dropbox/downloadFile' 33 33 - import type * as AppRockskyDropboxGetFiles from './types/app/rocksky/dropbox/getFiles' 34 34 - import type * as AppRockskyDropboxGetMetadata from './types/app/rocksky/dropbox/getMetadata' 35 35 - import type * as AppRockskyDropboxGetTemporaryLink from './types/app/rocksky/dropbox/getTemporaryLink' 36 36 - import type * as AppRockskyFeedGetNowPlayings from './types/app/rocksky/feed/getNowPlayings' 37 37 - import type * as AppRockskyFeedSearch from './types/app/rocksky/feed/search' 38 38 - import type * as AppRockskyGoogledriveDownloadFile from './types/app/rocksky/googledrive/downloadFile' 39 39 - import type * as AppRockskyGoogledriveGetFile from './types/app/rocksky/googledrive/getFile' 40 40 - import type * as AppRockskyGoogledriveGetFiles from './types/app/rocksky/googledrive/getFiles' 41 41 - import type * as AppRockskyLikeDislikeShout from './types/app/rocksky/like/dislikeShout' 42 42 - import type * as AppRockskyLikeDislikeSong from './types/app/rocksky/like/dislikeSong' 43 43 - import type * as AppRockskyLikeLikeShout from './types/app/rocksky/like/likeShout' 44 44 - import type * as AppRockskyLikeLikeSong from './types/app/rocksky/like/likeSong' 45 45 - import type * as AppRockskyPlayerAddDirectoryToQueue from './types/app/rocksky/player/addDirectoryToQueue' 46 46 - import type * as AppRockskyPlayerAddItemsToQueue from './types/app/rocksky/player/addItemsToQueue' 47 47 - import type * as AppRockskyPlayerGetCurrentlyPlaying from './types/app/rocksky/player/getCurrentlyPlaying' 48 48 - import type * as AppRockskyPlayerGetPlaybackQueue from './types/app/rocksky/player/getPlaybackQueue' 49 49 - import type * as AppRockskyPlayerNext from './types/app/rocksky/player/next' 50 50 - import type * as AppRockskyPlayerPause from './types/app/rocksky/player/pause' 51 51 - import type * as AppRockskyPlayerPlayDirectory from './types/app/rocksky/player/playDirectory' 52 52 - import type * as AppRockskyPlayerPlayFile from './types/app/rocksky/player/playFile' 53 53 - import type * as AppRockskyPlayerPlay from './types/app/rocksky/player/play' 54 54 - import type * as AppRockskyPlayerPrevious from './types/app/rocksky/player/previous' 55 55 - import type * as AppRockskyPlayerSeek from './types/app/rocksky/player/seek' 56 56 - import type * as AppRockskyPlaylistCreatePlaylist from './types/app/rocksky/playlist/createPlaylist' 57 57 - import type * as AppRockskyPlaylistGetPlaylist from './types/app/rocksky/playlist/getPlaylist' 58 58 - import type * as AppRockskyPlaylistGetPlaylists from './types/app/rocksky/playlist/getPlaylists' 59 59 - import type * as AppRockskyPlaylistInsertDirectory from './types/app/rocksky/playlist/insertDirectory' 60 60 - import type * as AppRockskyPlaylistInsertFiles from './types/app/rocksky/playlist/insertFiles' 61 61 - import type * as AppRockskyPlaylistRemovePlaylist from './types/app/rocksky/playlist/removePlaylist' 62 62 - import type * as AppRockskyPlaylistRemoveTrack from './types/app/rocksky/playlist/removeTrack' 63 63 - import type * as AppRockskyPlaylistStartPlaylist from './types/app/rocksky/playlist/startPlaylist' 64 64 - import type * as AppRockskyScrobbleCreateScrobble from './types/app/rocksky/scrobble/createScrobble' 65 65 - import type * as AppRockskyScrobbleGetScrobble from './types/app/rocksky/scrobble/getScrobble' 66 66 - import type * as AppRockskyScrobbleGetScrobbles from './types/app/rocksky/scrobble/getScrobbles' 67 67 - import type * as AppRockskyShoutCreateShout from './types/app/rocksky/shout/createShout' 68 68 - import type * as AppRockskyShoutGetAlbumShouts from './types/app/rocksky/shout/getAlbumShouts' 69 69 - import type * as AppRockskyShoutGetArtistShouts from './types/app/rocksky/shout/getArtistShouts' 70 70 - import type * as AppRockskyShoutGetProfileShouts from './types/app/rocksky/shout/getProfileShouts' 71 71 - import type * as AppRockskyShoutGetShoutReplies from './types/app/rocksky/shout/getShoutReplies' 72 72 - import type * as AppRockskyShoutGetTrackShouts from './types/app/rocksky/shout/getTrackShouts' 73 73 - import type * as AppRockskyShoutRemoveShout from './types/app/rocksky/shout/removeShout' 74 74 - import type * as AppRockskyShoutReplyShout from './types/app/rocksky/shout/replyShout' 75 75 - import type * as AppRockskyShoutReportShout from './types/app/rocksky/shout/reportShout' 76 76 - import type * as AppRockskySongCreateSong from './types/app/rocksky/song/createSong' 77 77 - import type * as AppRockskySongGetSong from './types/app/rocksky/song/getSong' 78 78 - import type * as AppRockskySongGetSongs from './types/app/rocksky/song/getSongs' 79 79 - import type * as AppRockskySpotifyGetCurrentlyPlaying from './types/app/rocksky/spotify/getCurrentlyPlaying' 80 80 - import type * as AppRockskySpotifyNext from './types/app/rocksky/spotify/next' 81 81 - import type * as AppRockskySpotifyPause from './types/app/rocksky/spotify/pause' 82 82 - import type * as AppRockskySpotifyPlay from './types/app/rocksky/spotify/play' 83 83 - import type * as AppRockskySpotifyPrevious from './types/app/rocksky/spotify/previous' 84 84 - import type * as AppRockskySpotifySeek from './types/app/rocksky/spotify/seek' 85 85 - import type * as AppRockskyStatsGetStats from './types/app/rocksky/stats/getStats' 6 6 + Server as XrpcServer, 7 7 + Options as XrpcOptions, 8 8 + AuthVerifier, 9 9 + StreamAuthVerifier, 10 10 + } from "@atproto/xrpc-server"; 11 11 + import { schemas } from "./lexicons"; 12 12 + import * as AppRockskyActorGetActorAlbums from "./types/app/rocksky/actor/getActorAlbums"; 13 13 + import * as AppRockskyActorGetActorArtists from "./types/app/rocksky/actor/getActorArtists"; 14 14 + import * as AppRockskyActorGetActorLovedSongs from "./types/app/rocksky/actor/getActorLovedSongs"; 15 15 + import * as AppRockskyActorGetActorPlaylists from "./types/app/rocksky/actor/getActorPlaylists"; 16 16 + import * as AppRockskyActorGetActorScrobbles from "./types/app/rocksky/actor/getActorScrobbles"; 17 17 + import * as AppRockskyActorGetActorSongs from "./types/app/rocksky/actor/getActorSongs"; 18 18 + import * as AppRockskyActorGetProfile from "./types/app/rocksky/actor/getProfile"; 19 19 + import * as AppRockskyAlbumGetAlbum from "./types/app/rocksky/album/getAlbum"; 20 20 + import * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums"; 21 21 + import * as AppRockskyAlbumGetAlbumTracks from "./types/app/rocksky/album/getAlbumTracks"; 22 22 + import * as AppRockskyApikeyCreateApikey from "./types/app/rocksky/apikey/createApikey"; 23 23 + import * as AppRockskyApikeyGetApikeys from "./types/app/rocksky/apikey/getApikeys"; 24 24 + import * as AppRockskyApikeyRemoveApikey from "./types/app/rocksky/apikey/removeApikey"; 25 25 + import * as AppRockskyApikeyUpdateApikey from "./types/app/rocksky/apikey/updateApikey"; 26 26 + import * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums"; 27 27 + import * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist"; 28 28 + import * as AppRockskyArtistGetArtistListeners from "./types/app/rocksky/artist/getArtistListeners"; 29 29 + import * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists"; 30 30 + import * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks"; 31 31 + import * as AppRockskyChartsGetScrobblesChart from "./types/app/rocksky/charts/getScrobblesChart"; 32 32 + import * as AppRockskyDropboxDownloadFile from "./types/app/rocksky/dropbox/downloadFile"; 33 33 + import * as AppRockskyDropboxGetFiles from "./types/app/rocksky/dropbox/getFiles"; 34 34 + import * as AppRockskyDropboxGetMetadata from "./types/app/rocksky/dropbox/getMetadata"; 35 35 + import * as AppRockskyDropboxGetTemporaryLink from "./types/app/rocksky/dropbox/getTemporaryLink"; 36 36 + import * as AppRockskyFeedGetNowPlayings from "./types/app/rocksky/feed/getNowPlayings"; 37 37 + import * as AppRockskyFeedSearch from "./types/app/rocksky/feed/search"; 38 38 + import * as AppRockskyGoogledriveDownloadFile from "./types/app/rocksky/googledrive/downloadFile"; 39 39 + import * as AppRockskyGoogledriveGetFile from "./types/app/rocksky/googledrive/getFile"; 40 40 + import * as AppRockskyGoogledriveGetFiles from "./types/app/rocksky/googledrive/getFiles"; 41 41 + import * as AppRockskyLikeDislikeShout from "./types/app/rocksky/like/dislikeShout"; 42 42 + import * as AppRockskyLikeDislikeSong from "./types/app/rocksky/like/dislikeSong"; 43 43 + import * as AppRockskyLikeLikeShout from "./types/app/rocksky/like/likeShout"; 44 44 + import * as AppRockskyLikeLikeSong from "./types/app/rocksky/like/likeSong"; 45 45 + import * as AppRockskyPlayerAddDirectoryToQueue from "./types/app/rocksky/player/addDirectoryToQueue"; 46 46 + import * as AppRockskyPlayerAddItemsToQueue from "./types/app/rocksky/player/addItemsToQueue"; 47 47 + import * as AppRockskyPlayerGetCurrentlyPlaying from "./types/app/rocksky/player/getCurrentlyPlaying"; 48 48 + import * as AppRockskyPlayerGetPlaybackQueue from "./types/app/rocksky/player/getPlaybackQueue"; 49 49 + import * as AppRockskyPlayerNext from "./types/app/rocksky/player/next"; 50 50 + import * as AppRockskyPlayerPause from "./types/app/rocksky/player/pause"; 51 51 + import * as AppRockskyPlayerPlayDirectory from "./types/app/rocksky/player/playDirectory"; 52 52 + import * as AppRockskyPlayerPlayFile from "./types/app/rocksky/player/playFile"; 53 53 + import * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play"; 54 54 + import * as AppRockskyPlayerPrevious from "./types/app/rocksky/player/previous"; 55 55 + import * as AppRockskyPlayerSeek from "./types/app/rocksky/player/seek"; 56 56 + import * as AppRockskyPlaylistCreatePlaylist from "./types/app/rocksky/playlist/createPlaylist"; 57 57 + import * as AppRockskyPlaylistGetPlaylist from "./types/app/rocksky/playlist/getPlaylist"; 58 58 + import * as AppRockskyPlaylistGetPlaylists from "./types/app/rocksky/playlist/getPlaylists"; 59 59 + import * as AppRockskyPlaylistInsertDirectory from "./types/app/rocksky/playlist/insertDirectory"; 60 60 + import * as AppRockskyPlaylistInsertFiles from "./types/app/rocksky/playlist/insertFiles"; 61 61 + import * as AppRockskyPlaylistRemovePlaylist from "./types/app/rocksky/playlist/removePlaylist"; 62 62 + import * as AppRockskyPlaylistRemoveTrack from "./types/app/rocksky/playlist/removeTrack"; 63 63 + import * as AppRockskyPlaylistStartPlaylist from "./types/app/rocksky/playlist/startPlaylist"; 64 64 + import * as AppRockskyScrobbleCreateScrobble from "./types/app/rocksky/scrobble/createScrobble"; 65 65 + import * as AppRockskyScrobbleGetScrobble from "./types/app/rocksky/scrobble/getScrobble"; 66 66 + import * as AppRockskyScrobbleGetScrobbles from "./types/app/rocksky/scrobble/getScrobbles"; 67 67 + import * as AppRockskyShoutCreateShout from "./types/app/rocksky/shout/createShout"; 68 68 + import * as AppRockskyShoutGetAlbumShouts from "./types/app/rocksky/shout/getAlbumShouts"; 69 69 + import * as AppRockskyShoutGetArtistShouts from "./types/app/rocksky/shout/getArtistShouts"; 70 70 + import * as AppRockskyShoutGetProfileShouts from "./types/app/rocksky/shout/getProfileShouts"; 71 71 + import * as AppRockskyShoutGetShoutReplies from "./types/app/rocksky/shout/getShoutReplies"; 72 72 + import * as AppRockskyShoutGetTrackShouts from "./types/app/rocksky/shout/getTrackShouts"; 73 73 + import * as AppRockskyShoutRemoveShout from "./types/app/rocksky/shout/removeShout"; 74 74 + import * as AppRockskyShoutReplyShout from "./types/app/rocksky/shout/replyShout"; 75 75 + import * as AppRockskyShoutReportShout from "./types/app/rocksky/shout/reportShout"; 76 76 + import * as AppRockskySongCreateSong from "./types/app/rocksky/song/createSong"; 77 77 + import * as AppRockskySongGetSong from "./types/app/rocksky/song/getSong"; 78 78 + import * as AppRockskySongGetSongs from "./types/app/rocksky/song/getSongs"; 79 79 + import * as AppRockskySpotifyGetCurrentlyPlaying from "./types/app/rocksky/spotify/getCurrentlyPlaying"; 80 80 + import * as AppRockskySpotifyNext from "./types/app/rocksky/spotify/next"; 81 81 + import * as AppRockskySpotifyPause from "./types/app/rocksky/spotify/pause"; 82 82 + import * as AppRockskySpotifyPlay from "./types/app/rocksky/spotify/play"; 83 83 + import * as AppRockskySpotifyPrevious from "./types/app/rocksky/spotify/previous"; 84 84 + import * as AppRockskySpotifySeek from "./types/app/rocksky/spotify/seek"; 85 85 + import * as AppRockskyStatsGetStats from "./types/app/rocksky/stats/getStats"; 86 86 87 87 export function createServer(options?: XrpcOptions): Server { 88 88 - return new Server(options) 88 88 + return new Server(options); 89 89 } 90 90 91 91 export class Server { 92 92 - xrpc: XrpcServer 93 93 - app: AppNS 94 94 - com: ComNS 92 92 + xrpc: XrpcServer; 93 93 + app: AppNS; 94 94 + com: ComNS; 95 95 96 96 constructor(options?: XrpcOptions) { 97 97 - this.xrpc = createXrpcServer(schemas, options) 98 98 - this.app = new AppNS(this) 99 99 - this.com = new ComNS(this) 97 97 + this.xrpc = createXrpcServer(schemas, options); 98 98 + this.app = new AppNS(this); 99 99 + this.com = new ComNS(this); 100 100 } 101 101 } 102 102 103 103 export class AppNS { 104 104 - _server: Server 105 105 - rocksky: AppRockskyNS 106 106 - bsky: AppBskyNS 104 104 + _server: Server; 105 105 + rocksky: AppRockskyNS; 106 106 + bsky: AppBskyNS; 107 107 108 108 constructor(server: Server) { 109 109 - this._server = server 110 110 - this.rocksky = new AppRockskyNS(server) 111 111 - this.bsky = new AppBskyNS(server) 109 109 + this._server = server; 110 110 + this.rocksky = new AppRockskyNS(server); 111 111 + this.bsky = new AppBskyNS(server); 112 112 } 113 113 } 114 114 115 115 export class AppRockskyNS { 116 116 - _server: Server 117 117 - actor: AppRockskyActorNS 118 118 - album: AppRockskyAlbumNS 119 119 - apikey: AppRockskyApikeyNS 120 120 - artist: AppRockskyArtistNS 121 121 - charts: AppRockskyChartsNS 122 122 - dropbox: AppRockskyDropboxNS 123 123 - feed: AppRockskyFeedNS 124 124 - googledrive: AppRockskyGoogledriveNS 125 125 - like: AppRockskyLikeNS 126 126 - player: AppRockskyPlayerNS 127 127 - playlist: AppRockskyPlaylistNS 128 128 - scrobble: AppRockskyScrobbleNS 129 129 - shout: AppRockskyShoutNS 130 130 - song: AppRockskySongNS 131 131 - spotify: AppRockskySpotifyNS 132 132 - stats: AppRockskyStatsNS 116 116 + _server: Server; 117 117 + actor: AppRockskyActorNS; 118 118 + album: AppRockskyAlbumNS; 119 119 + apikey: AppRockskyApikeyNS; 120 120 + artist: AppRockskyArtistNS; 121 121 + charts: AppRockskyChartsNS; 122 122 + dropbox: AppRockskyDropboxNS; 123 123 + feed: AppRockskyFeedNS; 124 124 + googledrive: AppRockskyGoogledriveNS; 125 125 + like: AppRockskyLikeNS; 126 126 + player: AppRockskyPlayerNS; 127 127 + playlist: AppRockskyPlaylistNS; 128 128 + scrobble: AppRockskyScrobbleNS; 129 129 + shout: AppRockskyShoutNS; 130 130 + song: AppRockskySongNS; 131 131 + spotify: AppRockskySpotifyNS; 132 132 + stats: AppRockskyStatsNS; 133 133 134 134 constructor(server: Server) { 135 135 - this._server = server 136 136 - this.actor = new AppRockskyActorNS(server) 137 137 - this.album = new AppRockskyAlbumNS(server) 138 138 - this.apikey = new AppRockskyApikeyNS(server) 139 139 - this.artist = new AppRockskyArtistNS(server) 140 140 - this.charts = new AppRockskyChartsNS(server) 141 141 - this.dropbox = new AppRockskyDropboxNS(server) 142 142 - this.feed = new AppRockskyFeedNS(server) 143 143 - this.googledrive = new AppRockskyGoogledriveNS(server) 144 144 - this.like = new AppRockskyLikeNS(server) 145 145 - this.player = new AppRockskyPlayerNS(server) 146 146 - this.playlist = new AppRockskyPlaylistNS(server) 147 147 - this.scrobble = new AppRockskyScrobbleNS(server) 148 148 - this.shout = new AppRockskyShoutNS(server) 149 149 - this.song = new AppRockskySongNS(server) 150 150 - this.spotify = new AppRockskySpotifyNS(server) 151 151 - this.stats = new AppRockskyStatsNS(server) 135 135 + this._server = server; 136 136 + this.actor = new AppRockskyActorNS(server); 137 137 + this.album = new AppRockskyAlbumNS(server); 138 138 + this.apikey = new AppRockskyApikeyNS(server); 139 139 + this.artist = new AppRockskyArtistNS(server); 140 140 + this.charts = new AppRockskyChartsNS(server); 141 141 + this.dropbox = new AppRockskyDropboxNS(server); 142 142 + this.feed = new AppRockskyFeedNS(server); 143 143 + this.googledrive = new AppRockskyGoogledriveNS(server); 144 144 + this.like = new AppRockskyLikeNS(server); 145 145 + this.player = new AppRockskyPlayerNS(server); 146 146 + this.playlist = new AppRockskyPlaylistNS(server); 147 147 + this.scrobble = new AppRockskyScrobbleNS(server); 148 148 + this.shout = new AppRockskyShoutNS(server); 149 149 + this.song = new AppRockskySongNS(server); 150 150 + this.spotify = new AppRockskySpotifyNS(server); 151 151 + this.stats = new AppRockskyStatsNS(server); 152 152 } 153 153 } 154 154 155 155 export class AppRockskyActorNS { 156 156 - _server: Server 156 156 + _server: Server; 157 157 158 158 constructor(server: Server) { 159 159 - this._server = server 159 159 + this._server = server; 160 160 } 161 161 162 162 getActorAlbums<AV extends AuthVerifier>( ··· 166 166 AppRockskyActorGetActorAlbums.HandlerReqCtx<ExtractAuth<AV>> 167 167 >, 168 168 ) { 169 169 - const nsid = 'app.rocksky.actor.getActorAlbums' // @ts-ignore 170 170 - return this._server.xrpc.method(nsid, cfg) 169 169 + const nsid = "app.rocksky.actor.getActorAlbums"; // @ts-ignore 170 170 + return this._server.xrpc.method(nsid, cfg); 171 171 } 172 172 173 173 getActorArtists<AV extends AuthVerifier>( ··· 177 177 AppRockskyActorGetActorArtists.HandlerReqCtx<ExtractAuth<AV>> 178 178 >, 179 179 ) { 180 180 - const nsid = 'app.rocksky.actor.getActorArtists' // @ts-ignore 181 181 - return this._server.xrpc.method(nsid, cfg) 180 180 + const nsid = "app.rocksky.actor.getActorArtists"; // @ts-ignore 181 181 + return this._server.xrpc.method(nsid, cfg); 182 182 } 183 183 184 184 getActorLovedSongs<AV extends AuthVerifier>( ··· 188 188 AppRockskyActorGetActorLovedSongs.HandlerReqCtx<ExtractAuth<AV>> 189 189 >, 190 190 ) { 191 191 - const nsid = 'app.rocksky.actor.getActorLovedSongs' // @ts-ignore 192 192 - return this._server.xrpc.method(nsid, cfg) 191 191 + const nsid = "app.rocksky.actor.getActorLovedSongs"; // @ts-ignore 192 192 + return this._server.xrpc.method(nsid, cfg); 193 193 } 194 194 195 195 getActorPlaylists<AV extends AuthVerifier>( ··· 199 199 AppRockskyActorGetActorPlaylists.HandlerReqCtx<ExtractAuth<AV>> 200 200 >, 201 201 ) { 202 202 - const nsid = 'app.rocksky.actor.getActorPlaylists' // @ts-ignore 203 203 - return this._server.xrpc.method(nsid, cfg) 202 202 + const nsid = "app.rocksky.actor.getActorPlaylists"; // @ts-ignore 203 203 + return this._server.xrpc.method(nsid, cfg); 204 204 } 205 205 206 206 getActorScrobbles<AV extends AuthVerifier>( ··· 210 210 AppRockskyActorGetActorScrobbles.HandlerReqCtx<ExtractAuth<AV>> 211 211 >, 212 212 ) { 213 213 - const nsid = 'app.rocksky.actor.getActorScrobbles' // @ts-ignore 214 214 - return this._server.xrpc.method(nsid, cfg) 213 213 + const nsid = "app.rocksky.actor.getActorScrobbles"; // @ts-ignore 214 214 + return this._server.xrpc.method(nsid, cfg); 215 215 } 216 216 217 217 getActorSongs<AV extends AuthVerifier>( ··· 221 221 AppRockskyActorGetActorSongs.HandlerReqCtx<ExtractAuth<AV>> 222 222 >, 223 223 ) { 224 224 - const nsid = 'app.rocksky.actor.getActorSongs' // @ts-ignore 225 225 - return this._server.xrpc.method(nsid, cfg) 224 224 + const nsid = "app.rocksky.actor.getActorSongs"; // @ts-ignore 225 225 + return this._server.xrpc.method(nsid, cfg); 226 226 } 227 227 228 228 getProfile<AV extends AuthVerifier>( ··· 232 232 AppRockskyActorGetProfile.HandlerReqCtx<ExtractAuth<AV>> 233 233 >, 234 234 ) { 235 235 - const nsid = 'app.rocksky.actor.getProfile' // @ts-ignore 236 236 - return this._server.xrpc.method(nsid, cfg) 235 235 + const nsid = "app.rocksky.actor.getProfile"; // @ts-ignore 236 236 + return this._server.xrpc.method(nsid, cfg); 237 237 } 238 238 } 239 239 240 240 export class AppRockskyAlbumNS { 241 241 - _server: Server 241 241 + _server: Server; 242 242 243 243 constructor(server: Server) { 244 244 - this._server = server 244 244 + this._server = server; 245 245 } 246 246 247 247 getAlbum<AV extends AuthVerifier>( ··· 251 251 AppRockskyAlbumGetAlbum.HandlerReqCtx<ExtractAuth<AV>> 252 252 >, 253 253 ) { 254 254 - const nsid = 'app.rocksky.album.getAlbum' // @ts-ignore 255 255 - return this._server.xrpc.method(nsid, cfg) 254 254 + const nsid = "app.rocksky.album.getAlbum"; // @ts-ignore 255 255 + return this._server.xrpc.method(nsid, cfg); 256 256 } 257 257 258 258 getAlbums<AV extends AuthVerifier>( ··· 262 262 AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>> 263 263 >, 264 264 ) { 265 265 - const nsid = 'app.rocksky.album.getAlbums' // @ts-ignore 266 266 - return this._server.xrpc.method(nsid, cfg) 265 265 + const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore 266 266 + return this._server.xrpc.method(nsid, cfg); 267 267 } 268 268 269 269 getAlbumTracks<AV extends AuthVerifier>( ··· 273 273 AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>> 274 274 >, 275 275 ) { 276 276 - const nsid = 'app.rocksky.album.getAlbumTracks' // @ts-ignore 277 277 - return this._server.xrpc.method(nsid, cfg) 276 276 + const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore 277 277 + return this._server.xrpc.method(nsid, cfg); 278 278 } 279 279 } 280 280 281 281 export class AppRockskyApikeyNS { 282 282 - _server: Server 282 282 + _server: Server; 283 283 284 284 constructor(server: Server) { 285 285 - this._server = server 285 285 + this._server = server; 286 286 } 287 287 288 288 createApikey<AV extends AuthVerifier>( ··· 292 292 AppRockskyApikeyCreateApikey.HandlerReqCtx<ExtractAuth<AV>> 293 293 >, 294 294 ) { 295 295 - const nsid = 'app.rocksky.apikey.createApikey' // @ts-ignore 296 296 - return this._server.xrpc.method(nsid, cfg) 295 295 + const nsid = "app.rocksky.apikey.createApikey"; // @ts-ignore 296 296 + return this._server.xrpc.method(nsid, cfg); 297 297 } 298 298 299 299 getApikeys<AV extends AuthVerifier>( ··· 303 303 AppRockskyApikeyGetApikeys.HandlerReqCtx<ExtractAuth<AV>> 304 304 >, 305 305 ) { 306 306 - const nsid = 'app.rocksky.apikey.getApikeys' // @ts-ignore 307 307 - return this._server.xrpc.method(nsid, cfg) 306 306 + const nsid = "app.rocksky.apikey.getApikeys"; // @ts-ignore 307 307 + return this._server.xrpc.method(nsid, cfg); 308 308 } 309 309 310 310 removeApikey<AV extends AuthVerifier>( ··· 314 314 AppRockskyApikeyRemoveApikey.HandlerReqCtx<ExtractAuth<AV>> 315 315 >, 316 316 ) { 317 317 - const nsid = 'app.rocksky.apikey.removeApikey' // @ts-ignore 318 318 - return this._server.xrpc.method(nsid, cfg) 317 317 + const nsid = "app.rocksky.apikey.removeApikey"; // @ts-ignore 318 318 + return this._server.xrpc.method(nsid, cfg); 319 319 } 320 320 321 321 updateApikey<AV extends AuthVerifier>( ··· 325 325 AppRockskyApikeyUpdateApikey.HandlerReqCtx<ExtractAuth<AV>> 326 326 >, 327 327 ) { 328 328 - const nsid = 'app.rocksky.apikey.updateApikey' // @ts-ignore 329 329 - return this._server.xrpc.method(nsid, cfg) 328 328 + const nsid = "app.rocksky.apikey.updateApikey"; // @ts-ignore 329 329 + return this._server.xrpc.method(nsid, cfg); 330 330 } 331 331 } 332 332 333 333 export class AppRockskyArtistNS { 334 334 - _server: Server 334 334 + _server: Server; 335 335 336 336 constructor(server: Server) { 337 337 - this._server = server 337 337 + this._server = server; 338 338 } 339 339 340 340 getArtistAlbums<AV extends AuthVerifier>( ··· 344 344 AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>> 345 345 >, 346 346 ) { 347 347 - const nsid = 'app.rocksky.artist.getArtistAlbums' // @ts-ignore 348 348 - return this._server.xrpc.method(nsid, cfg) 347 347 + const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore 348 348 + return this._server.xrpc.method(nsid, cfg); 349 349 } 350 350 351 351 getArtist<AV extends AuthVerifier>( ··· 355 355 AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>> 356 356 >, 357 357 ) { 358 358 - const nsid = 'app.rocksky.artist.getArtist' // @ts-ignore 359 359 - return this._server.xrpc.method(nsid, cfg) 358 358 + const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore 359 359 + return this._server.xrpc.method(nsid, cfg); 360 360 } 361 361 362 362 getArtistListeners<AV extends AuthVerifier>( ··· 366 366 AppRockskyArtistGetArtistListeners.HandlerReqCtx<ExtractAuth<AV>> 367 367 >, 368 368 ) { 369 369 - const nsid = 'app.rocksky.artist.getArtistListeners' // @ts-ignore 370 370 - return this._server.xrpc.method(nsid, cfg) 369 369 + const nsid = "app.rocksky.artist.getArtistListeners"; // @ts-ignore 370 370 + return this._server.xrpc.method(nsid, cfg); 371 371 } 372 372 373 373 getArtists<AV extends AuthVerifier>( ··· 377 377 AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>> 378 378 >, 379 379 ) { 380 380 - const nsid = 'app.rocksky.artist.getArtists' // @ts-ignore 381 381 - return this._server.xrpc.method(nsid, cfg) 380 380 + const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore 381 381 + return this._server.xrpc.method(nsid, cfg); 382 382 } 383 383 384 384 getArtistTracks<AV extends AuthVerifier>( ··· 388 388 AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>> 389 389 >, 390 390 ) { 391 391 - const nsid = 'app.rocksky.artist.getArtistTracks' // @ts-ignore 392 392 - return this._server.xrpc.method(nsid, cfg) 391 391 + const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore 392 392 + return this._server.xrpc.method(nsid, cfg); 393 393 } 394 394 } 395 395 396 396 export class AppRockskyChartsNS { 397 397 - _server: Server 397 397 + _server: Server; 398 398 399 399 constructor(server: Server) { 400 400 - this._server = server 400 400 + this._server = server; 401 401 } 402 402 403 403 getScrobblesChart<AV extends AuthVerifier>( ··· 407 407 AppRockskyChartsGetScrobblesChart.HandlerReqCtx<ExtractAuth<AV>> 408 408 >, 409 409 ) { 410 410 - const nsid = 'app.rocksky.charts.getScrobblesChart' // @ts-ignore 411 411 - return this._server.xrpc.method(nsid, cfg) 410 410 + const nsid = "app.rocksky.charts.getScrobblesChart"; // @ts-ignore 411 411 + return this._server.xrpc.method(nsid, cfg); 412 412 } 413 413 } 414 414 415 415 export class AppRockskyDropboxNS { 416 416 - _server: Server 416 416 + _server: Server; 417 417 418 418 constructor(server: Server) { 419 419 - this._server = server 419 419 + this._server = server; 420 420 } 421 421 422 422 downloadFile<AV extends AuthVerifier>( ··· 426 426 AppRockskyDropboxDownloadFile.HandlerReqCtx<ExtractAuth<AV>> 427 427 >, 428 428 ) { 429 429 - const nsid = 'app.rocksky.dropbox.downloadFile' // @ts-ignore 430 430 - return this._server.xrpc.method(nsid, cfg) 429 429 + const nsid = "app.rocksky.dropbox.downloadFile"; // @ts-ignore 430 430 + return this._server.xrpc.method(nsid, cfg); 431 431 } 432 432 433 433 getFiles<AV extends AuthVerifier>( ··· 437 437 AppRockskyDropboxGetFiles.HandlerReqCtx<ExtractAuth<AV>> 438 438 >, 439 439 ) { 440 440 - const nsid = 'app.rocksky.dropbox.getFiles' // @ts-ignore 441 441 - return this._server.xrpc.method(nsid, cfg) 440 440 + const nsid = "app.rocksky.dropbox.getFiles"; // @ts-ignore 441 441 + return this._server.xrpc.method(nsid, cfg); 442 442 } 443 443 444 444 getMetadata<AV extends AuthVerifier>( ··· 448 448 AppRockskyDropboxGetMetadata.HandlerReqCtx<ExtractAuth<AV>> 449 449 >, 450 450 ) { 451 451 - const nsid = 'app.rocksky.dropbox.getMetadata' // @ts-ignore 452 452 - return this._server.xrpc.method(nsid, cfg) 451 451 + const nsid = "app.rocksky.dropbox.getMetadata"; // @ts-ignore 452 452 + return this._server.xrpc.method(nsid, cfg); 453 453 } 454 454 455 455 getTemporaryLink<AV extends AuthVerifier>( ··· 459 459 AppRockskyDropboxGetTemporaryLink.HandlerReqCtx<ExtractAuth<AV>> 460 460 >, 461 461 ) { 462 462 - const nsid = 'app.rocksky.dropbox.getTemporaryLink' // @ts-ignore 463 463 - return this._server.xrpc.method(nsid, cfg) 462 462 + const nsid = "app.rocksky.dropbox.getTemporaryLink"; // @ts-ignore 463 463 + return this._server.xrpc.method(nsid, cfg); 464 464 } 465 465 } 466 466 467 467 export class AppRockskyFeedNS { 468 468 - _server: Server 468 468 + _server: Server; 469 469 470 470 constructor(server: Server) { 471 471 - this._server = server 471 471 + this._server = server; 472 472 } 473 473 474 474 getNowPlayings<AV extends AuthVerifier>( ··· 478 478 AppRockskyFeedGetNowPlayings.HandlerReqCtx<ExtractAuth<AV>> 479 479 >, 480 480 ) { 481 481 - const nsid = 'app.rocksky.feed.getNowPlayings' // @ts-ignore 482 482 - return this._server.xrpc.method(nsid, cfg) 481 481 + const nsid = "app.rocksky.feed.getNowPlayings"; // @ts-ignore 482 482 + return this._server.xrpc.method(nsid, cfg); 483 483 } 484 484 485 485 search<AV extends AuthVerifier>( ··· 489 489 AppRockskyFeedSearch.HandlerReqCtx<ExtractAuth<AV>> 490 490 >, 491 491 ) { 492 492 - const nsid = 'app.rocksky.feed.search' // @ts-ignore 493 493 - return this._server.xrpc.method(nsid, cfg) 492 492 + const nsid = "app.rocksky.feed.search"; // @ts-ignore 493 493 + return this._server.xrpc.method(nsid, cfg); 494 494 } 495 495 } 496 496 497 497 export class AppRockskyGoogledriveNS { 498 498 - _server: Server 498 498 + _server: Server; 499 499 500 500 constructor(server: Server) { 501 501 - this._server = server 501 501 + this._server = server; 502 502 } 503 503 504 504 downloadFile<AV extends AuthVerifier>( ··· 508 508 AppRockskyGoogledriveDownloadFile.HandlerReqCtx<ExtractAuth<AV>> 509 509 >, 510 510 ) { 511 511 - const nsid = 'app.rocksky.googledrive.downloadFile' // @ts-ignore 512 512 - return this._server.xrpc.method(nsid, cfg) 511 511 + const nsid = "app.rocksky.googledrive.downloadFile"; // @ts-ignore 512 512 + return this._server.xrpc.method(nsid, cfg); 513 513 } 514 514 515 515 getFile<AV extends AuthVerifier>( ··· 519 519 AppRockskyGoogledriveGetFile.HandlerReqCtx<ExtractAuth<AV>> 520 520 >, 521 521 ) { 522 522 - const nsid = 'app.rocksky.googledrive.getFile' // @ts-ignore 523 523 - return this._server.xrpc.method(nsid, cfg) 522 522 + const nsid = "app.rocksky.googledrive.getFile"; // @ts-ignore 523 523 + return this._server.xrpc.method(nsid, cfg); 524 524 } 525 525 526 526 getFiles<AV extends AuthVerifier>( ··· 530 530 AppRockskyGoogledriveGetFiles.HandlerReqCtx<ExtractAuth<AV>> 531 531 >, 532 532 ) { 533 533 - const nsid = 'app.rocksky.googledrive.getFiles' // @ts-ignore 534 534 - return this._server.xrpc.method(nsid, cfg) 533 533 + const nsid = "app.rocksky.googledrive.getFiles"; // @ts-ignore 534 534 + return this._server.xrpc.method(nsid, cfg); 535 535 } 536 536 } 537 537 538 538 export class AppRockskyLikeNS { 539 539 - _server: Server 539 539 + _server: Server; 540 540 541 541 constructor(server: Server) { 542 542 - this._server = server 542 542 + this._server = server; 543 543 } 544 544 545 545 dislikeShout<AV extends AuthVerifier>( ··· 549 549 AppRockskyLikeDislikeShout.HandlerReqCtx<ExtractAuth<AV>> 550 550 >, 551 551 ) { 552 552 - const nsid = 'app.rocksky.like.dislikeShout' // @ts-ignore 553 553 - return this._server.xrpc.method(nsid, cfg) 552 552 + const nsid = "app.rocksky.like.dislikeShout"; // @ts-ignore 553 553 + return this._server.xrpc.method(nsid, cfg); 554 554 } 555 555 556 556 dislikeSong<AV extends AuthVerifier>( ··· 560 560 AppRockskyLikeDislikeSong.HandlerReqCtx<ExtractAuth<AV>> 561 561 >, 562 562 ) { 563 563 - const nsid = 'app.rocksky.like.dislikeSong' // @ts-ignore 564 564 - return this._server.xrpc.method(nsid, cfg) 563 563 + const nsid = "app.rocksky.like.dislikeSong"; // @ts-ignore 564 564 + return this._server.xrpc.method(nsid, cfg); 565 565 } 566 566 567 567 likeShout<AV extends AuthVerifier>( ··· 571 571 AppRockskyLikeLikeShout.HandlerReqCtx<ExtractAuth<AV>> 572 572 >, 573 573 ) { 574 574 - const nsid = 'app.rocksky.like.likeShout' // @ts-ignore 575 575 - return this._server.xrpc.method(nsid, cfg) 574 574 + const nsid = "app.rocksky.like.likeShout"; // @ts-ignore 575 575 + return this._server.xrpc.method(nsid, cfg); 576 576 } 577 577 578 578 likeSong<AV extends AuthVerifier>( ··· 582 582 AppRockskyLikeLikeSong.HandlerReqCtx<ExtractAuth<AV>> 583 583 >, 584 584 ) { 585 585 - const nsid = 'app.rocksky.like.likeSong' // @ts-ignore 586 586 - return this._server.xrpc.method(nsid, cfg) 585 585 + const nsid = "app.rocksky.like.likeSong"; // @ts-ignore 586 586 + return this._server.xrpc.method(nsid, cfg); 587 587 } 588 588 } 589 589 590 590 export class AppRockskyPlayerNS { 591 591 - _server: Server 591 591 + _server: Server; 592 592 593 593 constructor(server: Server) { 594 594 - this._server = server 594 594 + this._server = server; 595 595 } 596 596 597 597 addDirectoryToQueue<AV extends AuthVerifier>( ··· 601 601 AppRockskyPlayerAddDirectoryToQueue.HandlerReqCtx<ExtractAuth<AV>> 602 602 >, 603 603 ) { 604 604 - const nsid = 'app.rocksky.player.addDirectoryToQueue' // @ts-ignore 605 605 - return this._server.xrpc.method(nsid, cfg) 604 604 + const nsid = "app.rocksky.player.addDirectoryToQueue"; // @ts-ignore 605 605 + return this._server.xrpc.method(nsid, cfg); 606 606 } 607 607 608 608 addItemsToQueue<AV extends AuthVerifier>( ··· 612 612 AppRockskyPlayerAddItemsToQueue.HandlerReqCtx<ExtractAuth<AV>> 613 613 >, 614 614 ) { 615 615 - const nsid = 'app.rocksky.player.addItemsToQueue' // @ts-ignore 616 616 - return this._server.xrpc.method(nsid, cfg) 615 615 + const nsid = "app.rocksky.player.addItemsToQueue"; // @ts-ignore 616 616 + return this._server.xrpc.method(nsid, cfg); 617 617 } 618 618 619 619 getCurrentlyPlaying<AV extends AuthVerifier>( ··· 623 623 AppRockskyPlayerGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>> 624 624 >, 625 625 ) { 626 626 - const nsid = 'app.rocksky.player.getCurrentlyPlaying' // @ts-ignore 627 627 - return this._server.xrpc.method(nsid, cfg) 626 626 + const nsid = "app.rocksky.player.getCurrentlyPlaying"; // @ts-ignore 627 627 + return this._server.xrpc.method(nsid, cfg); 628 628 } 629 629 630 630 getPlaybackQueue<AV extends AuthVerifier>( ··· 634 634 AppRockskyPlayerGetPlaybackQueue.HandlerReqCtx<ExtractAuth<AV>> 635 635 >, 636 636 ) { 637 637 - const nsid = 'app.rocksky.player.getPlaybackQueue' // @ts-ignore 638 638 - return this._server.xrpc.method(nsid, cfg) 637 637 + const nsid = "app.rocksky.player.getPlaybackQueue"; // @ts-ignore 638 638 + return this._server.xrpc.method(nsid, cfg); 639 639 } 640 640 641 641 next<AV extends AuthVerifier>( ··· 645 645 AppRockskyPlayerNext.HandlerReqCtx<ExtractAuth<AV>> 646 646 >, 647 647 ) { 648 648 - const nsid = 'app.rocksky.player.next' // @ts-ignore 649 649 - return this._server.xrpc.method(nsid, cfg) 648 648 + const nsid = "app.rocksky.player.next"; // @ts-ignore 649 649 + return this._server.xrpc.method(nsid, cfg); 650 650 } 651 651 652 652 pause<AV extends AuthVerifier>( ··· 656 656 AppRockskyPlayerPause.HandlerReqCtx<ExtractAuth<AV>> 657 657 >, 658 658 ) { 659 659 - const nsid = 'app.rocksky.player.pause' // @ts-ignore 660 660 - return this._server.xrpc.method(nsid, cfg) 659 659 + const nsid = "app.rocksky.player.pause"; // @ts-ignore 660 660 + return this._server.xrpc.method(nsid, cfg); 661 661 } 662 662 663 663 playDirectory<AV extends AuthVerifier>( ··· 667 667 AppRockskyPlayerPlayDirectory.HandlerReqCtx<ExtractAuth<AV>> 668 668 >, 669 669 ) { 670 670 - const nsid = 'app.rocksky.player.playDirectory' // @ts-ignore 671 671 - return this._server.xrpc.method(nsid, cfg) 670 670 + const nsid = "app.rocksky.player.playDirectory"; // @ts-ignore 671 671 + return this._server.xrpc.method(nsid, cfg); 672 672 } 673 673 674 674 playFile<AV extends AuthVerifier>( ··· 678 678 AppRockskyPlayerPlayFile.HandlerReqCtx<ExtractAuth<AV>> 679 679 >, 680 680 ) { 681 681 - const nsid = 'app.rocksky.player.playFile' // @ts-ignore 682 682 - return this._server.xrpc.method(nsid, cfg) 681 681 + const nsid = "app.rocksky.player.playFile"; // @ts-ignore 682 682 + return this._server.xrpc.method(nsid, cfg); 683 683 } 684 684 685 685 play<AV extends AuthVerifier>( ··· 689 689 AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>> 690 690 >, 691 691 ) { 692 692 - const nsid = 'app.rocksky.player.play' // @ts-ignore 693 693 - return this._server.xrpc.method(nsid, cfg) 692 692 + const nsid = "app.rocksky.player.play"; // @ts-ignore 693 693 + return this._server.xrpc.method(nsid, cfg); 694 694 } 695 695 696 696 previous<AV extends AuthVerifier>( ··· 700 700 AppRockskyPlayerPrevious.HandlerReqCtx<ExtractAuth<AV>> 701 701 >, 702 702 ) { 703 703 - const nsid = 'app.rocksky.player.previous' // @ts-ignore 704 704 - return this._server.xrpc.method(nsid, cfg) 703 703 + const nsid = "app.rocksky.player.previous"; // @ts-ignore 704 704 + return this._server.xrpc.method(nsid, cfg); 705 705 } 706 706 707 707 seek<AV extends AuthVerifier>( ··· 711 711 AppRockskyPlayerSeek.HandlerReqCtx<ExtractAuth<AV>> 712 712 >, 713 713 ) { 714 714 - const nsid = 'app.rocksky.player.seek' // @ts-ignore 715 715 - return this._server.xrpc.method(nsid, cfg) 714 714 + const nsid = "app.rocksky.player.seek"; // @ts-ignore 715 715 + return this._server.xrpc.method(nsid, cfg); 716 716 } 717 717 } 718 718 719 719 export class AppRockskyPlaylistNS { 720 720 - _server: Server 720 720 + _server: Server; 721 721 722 722 constructor(server: Server) { 723 723 - this._server = server 723 723 + this._server = server; 724 724 } 725 725 726 726 createPlaylist<AV extends AuthVerifier>( ··· 730 730 AppRockskyPlaylistCreatePlaylist.HandlerReqCtx<ExtractAuth<AV>> 731 731 >, 732 732 ) { 733 733 - const nsid = 'app.rocksky.playlist.createPlaylist' // @ts-ignore 734 734 - return this._server.xrpc.method(nsid, cfg) 733 733 + const nsid = "app.rocksky.playlist.createPlaylist"; // @ts-ignore 734 734 + return this._server.xrpc.method(nsid, cfg); 735 735 } 736 736 737 737 getPlaylist<AV extends AuthVerifier>( ··· 741 741 AppRockskyPlaylistGetPlaylist.HandlerReqCtx<ExtractAuth<AV>> 742 742 >, 743 743 ) { 744 744 - const nsid = 'app.rocksky.playlist.getPlaylist' // @ts-ignore 745 745 - return this._server.xrpc.method(nsid, cfg) 744 744 + const nsid = "app.rocksky.playlist.getPlaylist"; // @ts-ignore 745 745 + return this._server.xrpc.method(nsid, cfg); 746 746 } 747 747 748 748 getPlaylists<AV extends AuthVerifier>( ··· 752 752 AppRockskyPlaylistGetPlaylists.HandlerReqCtx<ExtractAuth<AV>> 753 753 >, 754 754 ) { 755 755 - const nsid = 'app.rocksky.playlist.getPlaylists' // @ts-ignore 756 756 - return this._server.xrpc.method(nsid, cfg) 755 755 + const nsid = "app.rocksky.playlist.getPlaylists"; // @ts-ignore 756 756 + return this._server.xrpc.method(nsid, cfg); 757 757 } 758 758 759 759 insertDirectory<AV extends AuthVerifier>( ··· 763 763 AppRockskyPlaylistInsertDirectory.HandlerReqCtx<ExtractAuth<AV>> 764 764 >, 765 765 ) { 766 766 - const nsid = 'app.rocksky.playlist.insertDirectory' // @ts-ignore 767 767 - return this._server.xrpc.method(nsid, cfg) 766 766 + const nsid = "app.rocksky.playlist.insertDirectory"; // @ts-ignore 767 767 + return this._server.xrpc.method(nsid, cfg); 768 768 } 769 769 770 770 insertFiles<AV extends AuthVerifier>( ··· 774 774 AppRockskyPlaylistInsertFiles.HandlerReqCtx<ExtractAuth<AV>> 775 775 >, 776 776 ) { 777 777 - const nsid = 'app.rocksky.playlist.insertFiles' // @ts-ignore 778 778 - return this._server.xrpc.method(nsid, cfg) 777 777 + const nsid = "app.rocksky.playlist.insertFiles"; // @ts-ignore 778 778 + return this._server.xrpc.method(nsid, cfg); 779 779 } 780 780 781 781 removePlaylist<AV extends AuthVerifier>( ··· 785 785 AppRockskyPlaylistRemovePlaylist.HandlerReqCtx<ExtractAuth<AV>> 786 786 >, 787 787 ) { 788 788 - const nsid = 'app.rocksky.playlist.removePlaylist' // @ts-ignore 789 789 - return this._server.xrpc.method(nsid, cfg) 788 788 + const nsid = "app.rocksky.playlist.removePlaylist"; // @ts-ignore 789 789 + return this._server.xrpc.method(nsid, cfg); 790 790 } 791 791 792 792 removeTrack<AV extends AuthVerifier>( ··· 796 796 AppRockskyPlaylistRemoveTrack.HandlerReqCtx<ExtractAuth<AV>> 797 797 >, 798 798 ) { 799 799 - const nsid = 'app.rocksky.playlist.removeTrack' // @ts-ignore 800 800 - return this._server.xrpc.method(nsid, cfg) 799 799 + const nsid = "app.rocksky.playlist.removeTrack"; // @ts-ignore 800 800 + return this._server.xrpc.method(nsid, cfg); 801 801 } 802 802 803 803 startPlaylist<AV extends AuthVerifier>( ··· 807 807 AppRockskyPlaylistStartPlaylist.HandlerReqCtx<ExtractAuth<AV>> 808 808 >, 809 809 ) { 810 810 - const nsid = 'app.rocksky.playlist.startPlaylist' // @ts-ignore 811 811 - return this._server.xrpc.method(nsid, cfg) 810 810 + const nsid = "app.rocksky.playlist.startPlaylist"; // @ts-ignore 811 811 + return this._server.xrpc.method(nsid, cfg); 812 812 } 813 813 } 814 814 815 815 export class AppRockskyScrobbleNS { 816 816 - _server: Server 816 816 + _server: Server; 817 817 818 818 constructor(server: Server) { 819 819 - this._server = server 819 819 + this._server = server; 820 820 } 821 821 822 822 createScrobble<AV extends AuthVerifier>( ··· 826 826 AppRockskyScrobbleCreateScrobble.HandlerReqCtx<ExtractAuth<AV>> 827 827 >, 828 828 ) { 829 829 - const nsid = 'app.rocksky.scrobble.createScrobble' // @ts-ignore 830 830 - return this._server.xrpc.method(nsid, cfg) 829 829 + const nsid = "app.rocksky.scrobble.createScrobble"; // @ts-ignore 830 830 + return this._server.xrpc.method(nsid, cfg); 831 831 } 832 832 833 833 getScrobble<AV extends AuthVerifier>( ··· 837 837 AppRockskyScrobbleGetScrobble.HandlerReqCtx<ExtractAuth<AV>> 838 838 >, 839 839 ) { 840 840 - const nsid = 'app.rocksky.scrobble.getScrobble' // @ts-ignore 841 841 - return this._server.xrpc.method(nsid, cfg) 840 840 + const nsid = "app.rocksky.scrobble.getScrobble"; // @ts-ignore 841 841 + return this._server.xrpc.method(nsid, cfg); 842 842 } 843 843 844 844 getScrobbles<AV extends AuthVerifier>( ··· 848 848 AppRockskyScrobbleGetScrobbles.HandlerReqCtx<ExtractAuth<AV>> 849 849 >, 850 850 ) { 851 851 - const nsid = 'app.rocksky.scrobble.getScrobbles' // @ts-ignore 852 852 - return this._server.xrpc.method(nsid, cfg) 851 851 + const nsid = "app.rocksky.scrobble.getScrobbles"; // @ts-ignore 852 852 + return this._server.xrpc.method(nsid, cfg); 853 853 } 854 854 } 855 855 856 856 export class AppRockskyShoutNS { 857 857 - _server: Server 857 857 + _server: Server; 858 858 859 859 constructor(server: Server) { 860 860 - this._server = server 860 860 + this._server = server; 861 861 } 862 862 863 863 createShout<AV extends AuthVerifier>( ··· 867 867 AppRockskyShoutCreateShout.HandlerReqCtx<ExtractAuth<AV>> 868 868 >, 869 869 ) { 870 870 - const nsid = 'app.rocksky.shout.createShout' // @ts-ignore 871 871 - return this._server.xrpc.method(nsid, cfg) 870 870 + const nsid = "app.rocksky.shout.createShout"; // @ts-ignore 871 871 + return this._server.xrpc.method(nsid, cfg); 872 872 } 873 873 874 874 getAlbumShouts<AV extends AuthVerifier>( ··· 878 878 AppRockskyShoutGetAlbumShouts.HandlerReqCtx<ExtractAuth<AV>> 879 879 >, 880 880 ) { 881 881 - const nsid = 'app.rocksky.shout.getAlbumShouts' // @ts-ignore 882 882 - return this._server.xrpc.method(nsid, cfg) 881 881 + const nsid = "app.rocksky.shout.getAlbumShouts"; // @ts-ignore 882 882 + return this._server.xrpc.method(nsid, cfg); 883 883 } 884 884 885 885 getArtistShouts<AV extends AuthVerifier>( ··· 889 889 AppRockskyShoutGetArtistShouts.HandlerReqCtx<ExtractAuth<AV>> 890 890 >, 891 891 ) { 892 892 - const nsid = 'app.rocksky.shout.getArtistShouts' // @ts-ignore 893 893 - return this._server.xrpc.method(nsid, cfg) 892 892 + const nsid = "app.rocksky.shout.getArtistShouts"; // @ts-ignore 893 893 + return this._server.xrpc.method(nsid, cfg); 894 894 } 895 895 896 896 getProfileShouts<AV extends AuthVerifier>( ··· 900 900 AppRockskyShoutGetProfileShouts.HandlerReqCtx<ExtractAuth<AV>> 901 901 >, 902 902 ) { 903 903 - const nsid = 'app.rocksky.shout.getProfileShouts' // @ts-ignore 904 904 - return this._server.xrpc.method(nsid, cfg) 903 903 + const nsid = "app.rocksky.shout.getProfileShouts"; // @ts-ignore 904 904 + return this._server.xrpc.method(nsid, cfg); 905 905 } 906 906 907 907 getShoutReplies<AV extends AuthVerifier>( ··· 911 911 AppRockskyShoutGetShoutReplies.HandlerReqCtx<ExtractAuth<AV>> 912 912 >, 913 913 ) { 914 914 - const nsid = 'app.rocksky.shout.getShoutReplies' // @ts-ignore 915 915 - return this._server.xrpc.method(nsid, cfg) 914 914 + const nsid = "app.rocksky.shout.getShoutReplies"; // @ts-ignore 915 915 + return this._server.xrpc.method(nsid, cfg); 916 916 } 917 917 918 918 getTrackShouts<AV extends AuthVerifier>( ··· 922 922 AppRockskyShoutGetTrackShouts.HandlerReqCtx<ExtractAuth<AV>> 923 923 >, 924 924 ) { 925 925 - const nsid = 'app.rocksky.shout.getTrackShouts' // @ts-ignore 926 926 - return this._server.xrpc.method(nsid, cfg) 925 925 + const nsid = "app.rocksky.shout.getTrackShouts"; // @ts-ignore 926 926 + return this._server.xrpc.method(nsid, cfg); 927 927 } 928 928 929 929 removeShout<AV extends AuthVerifier>( ··· 933 933 AppRockskyShoutRemoveShout.HandlerReqCtx<ExtractAuth<AV>> 934 934 >, 935 935 ) { 936 936 - const nsid = 'app.rocksky.shout.removeShout' // @ts-ignore 937 937 - return this._server.xrpc.method(nsid, cfg) 936 936 + const nsid = "app.rocksky.shout.removeShout"; // @ts-ignore 937 937 + return this._server.xrpc.method(nsid, cfg); 938 938 } 939 939 940 940 replyShout<AV extends AuthVerifier>( ··· 944 944 AppRockskyShoutReplyShout.HandlerReqCtx<ExtractAuth<AV>> 945 945 >, 946 946 ) { 947 947 - const nsid = 'app.rocksky.shout.replyShout' // @ts-ignore 948 948 - return this._server.xrpc.method(nsid, cfg) 947 947 + const nsid = "app.rocksky.shout.replyShout"; // @ts-ignore 948 948 + return this._server.xrpc.method(nsid, cfg); 949 949 } 950 950 951 951 reportShout<AV extends AuthVerifier>( ··· 955 955 AppRockskyShoutReportShout.HandlerReqCtx<ExtractAuth<AV>> 956 956 >, 957 957 ) { 958 958 - const nsid = 'app.rocksky.shout.reportShout' // @ts-ignore 959 959 - return this._server.xrpc.method(nsid, cfg) 958 958 + const nsid = "app.rocksky.shout.reportShout"; // @ts-ignore 959 959 + return this._server.xrpc.method(nsid, cfg); 960 960 } 961 961 } 962 962 963 963 export class AppRockskySongNS { 964 964 - _server: Server 964 964 + _server: Server; 965 965 966 966 constructor(server: Server) { 967 967 - this._server = server 967 967 + this._server = server; 968 968 } 969 969 970 970 createSong<AV extends AuthVerifier>( ··· 974 974 AppRockskySongCreateSong.HandlerReqCtx<ExtractAuth<AV>> 975 975 >, 976 976 ) { 977 977 - const nsid = 'app.rocksky.song.createSong' // @ts-ignore 978 978 - return this._server.xrpc.method(nsid, cfg) 977 977 + const nsid = "app.rocksky.song.createSong"; // @ts-ignore 978 978 + return this._server.xrpc.method(nsid, cfg); 979 979 } 980 980 981 981 getSong<AV extends AuthVerifier>( ··· 985 985 AppRockskySongGetSong.HandlerReqCtx<ExtractAuth<AV>> 986 986 >, 987 987 ) { 988 988 - const nsid = 'app.rocksky.song.getSong' // @ts-ignore 989 989 - return this._server.xrpc.method(nsid, cfg) 988 988 + const nsid = "app.rocksky.song.getSong"; // @ts-ignore 989 989 + return this._server.xrpc.method(nsid, cfg); 990 990 } 991 991 992 992 getSongs<AV extends AuthVerifier>( ··· 996 996 AppRockskySongGetSongs.HandlerReqCtx<ExtractAuth<AV>> 997 997 >, 998 998 ) { 999 999 - const nsid = 'app.rocksky.song.getSongs' // @ts-ignore 1000 1000 - return this._server.xrpc.method(nsid, cfg) 999 999 + const nsid = "app.rocksky.song.getSongs"; // @ts-ignore 1000 1000 + return this._server.xrpc.method(nsid, cfg); 1001 1001 } 1002 1002 } 1003 1003 1004 1004 export class AppRockskySpotifyNS { 1005 1005 - _server: Server 1005 1005 + _server: Server; 1006 1006 1007 1007 constructor(server: Server) { 1008 1008 - this._server = server 1008 1008 + this._server = server; 1009 1009 } 1010 1010 1011 1011 getCurrentlyPlaying<AV extends AuthVerifier>( ··· 1015 1015 AppRockskySpotifyGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>> 1016 1016 >, 1017 1017 ) { 1018 1018 - const nsid = 'app.rocksky.spotify.getCurrentlyPlaying' // @ts-ignore 1019 1019 - return this._server.xrpc.method(nsid, cfg) 1018 1018 + const nsid = "app.rocksky.spotify.getCurrentlyPlaying"; // @ts-ignore 1019 1019 + return this._server.xrpc.method(nsid, cfg); 1020 1020 } 1021 1021 1022 1022 next<AV extends AuthVerifier>( ··· 1026 1026 AppRockskySpotifyNext.HandlerReqCtx<ExtractAuth<AV>> 1027 1027 >, 1028 1028 ) { 1029 1029 - const nsid = 'app.rocksky.spotify.next' // @ts-ignore 1030 1030 - return this._server.xrpc.method(nsid, cfg) 1029 1029 + const nsid = "app.rocksky.spotify.next"; // @ts-ignore 1030 1030 + return this._server.xrpc.method(nsid, cfg); 1031 1031 } 1032 1032 1033 1033 pause<AV extends AuthVerifier>( ··· 1037 1037 AppRockskySpotifyPause.HandlerReqCtx<ExtractAuth<AV>> 1038 1038 >, 1039 1039 ) { 1040 1040 - const nsid = 'app.rocksky.spotify.pause' // @ts-ignore 1041 1041 - return this._server.xrpc.method(nsid, cfg) 1040 1040 + const nsid = "app.rocksky.spotify.pause"; // @ts-ignore 1041 1041 + return this._server.xrpc.method(nsid, cfg); 1042 1042 } 1043 1043 1044 1044 play<AV extends AuthVerifier>( ··· 1048 1048 AppRockskySpotifyPlay.HandlerReqCtx<ExtractAuth<AV>> 1049 1049 >, 1050 1050 ) { 1051 1051 - const nsid = 'app.rocksky.spotify.play' // @ts-ignore 1052 1052 - return this._server.xrpc.method(nsid, cfg) 1051 1051 + const nsid = "app.rocksky.spotify.play"; // @ts-ignore 1052 1052 + return this._server.xrpc.method(nsid, cfg); 1053 1053 } 1054 1054 1055 1055 previous<AV extends AuthVerifier>( ··· 1059 1059 AppRockskySpotifyPrevious.HandlerReqCtx<ExtractAuth<AV>> 1060 1060 >, 1061 1061 ) { 1062 1062 - const nsid = 'app.rocksky.spotify.previous' // @ts-ignore 1063 1063 - return this._server.xrpc.method(nsid, cfg) 1062 1062 + const nsid = "app.rocksky.spotify.previous"; // @ts-ignore 1063 1063 + return this._server.xrpc.method(nsid, cfg); 1064 1064 } 1065 1065 1066 1066 seek<AV extends AuthVerifier>( ··· 1070 1070 AppRockskySpotifySeek.HandlerReqCtx<ExtractAuth<AV>> 1071 1071 >, 1072 1072 ) { 1073 1073 - const nsid = 'app.rocksky.spotify.seek' // @ts-ignore 1074 1074 - return this._server.xrpc.method(nsid, cfg) 1073 1073 + const nsid = "app.rocksky.spotify.seek"; // @ts-ignore 1074 1074 + return this._server.xrpc.method(nsid, cfg); 1075 1075 } 1076 1076 } 1077 1077 1078 1078 export class AppRockskyStatsNS { 1079 1079 - _server: Server 1079 1079 + _server: Server; 1080 1080 1081 1081 constructor(server: Server) { 1082 1082 - this._server = server 1082 1082 + this._server = server; 1083 1083 } 1084 1084 1085 1085 getStats<AV extends AuthVerifier>( ··· 1089 1089 AppRockskyStatsGetStats.HandlerReqCtx<ExtractAuth<AV>> 1090 1090 >, 1091 1091 ) { 1092 1092 - const nsid = 'app.rocksky.stats.getStats' // @ts-ignore 1093 1093 - return this._server.xrpc.method(nsid, cfg) 1092 1092 + const nsid = "app.rocksky.stats.getStats"; // @ts-ignore 1093 1093 + return this._server.xrpc.method(nsid, cfg); 1094 1094 } 1095 1095 } 1096 1096 1097 1097 export class AppBskyNS { 1098 1098 - _server: Server 1099 1099 - actor: AppBskyActorNS 1098 1098 + _server: Server; 1099 1099 + actor: AppBskyActorNS; 1100 1100 1101 1101 constructor(server: Server) { 1102 1102 - this._server = server 1103 1103 - this.actor = new AppBskyActorNS(server) 1102 1102 + this._server = server; 1103 1103 + this.actor = new AppBskyActorNS(server); 1104 1104 } 1105 1105 } 1106 1106 1107 1107 export class AppBskyActorNS { 1108 1108 - _server: Server 1108 1108 + _server: Server; 1109 1109 1110 1110 constructor(server: Server) { 1111 1111 - this._server = server 1111 1111 + this._server = server; 1112 1112 } 1113 1113 } 1114 1114 1115 1115 export class ComNS { 1116 1116 - _server: Server 1117 1117 - atproto: ComAtprotoNS 1116 1116 + _server: Server; 1117 1117 + atproto: ComAtprotoNS; 1118 1118 1119 1119 constructor(server: Server) { 1120 1120 - this._server = server 1121 1121 - this.atproto = new ComAtprotoNS(server) 1120 1120 + this._server = server; 1121 1121 + this.atproto = new ComAtprotoNS(server); 1122 1122 } 1123 1123 } 1124 1124 1125 1125 export class ComAtprotoNS { 1126 1126 - _server: Server 1127 1127 - repo: ComAtprotoRepoNS 1126 1126 + _server: Server; 1127 1127 + repo: ComAtprotoRepoNS; 1128 1128 1129 1129 constructor(server: Server) { 1130 1130 - this._server = server 1131 1131 - this.repo = new ComAtprotoRepoNS(server) 1130 1130 + this._server = server; 1131 1131 + this.repo = new ComAtprotoRepoNS(server); 1132 1132 } 1133 1133 } 1134 1134 1135 1135 export class ComAtprotoRepoNS { 1136 1136 - _server: Server 1136 1136 + _server: Server; 1137 1137 1138 1138 constructor(server: Server) { 1139 1139 - this._server = server 1139 1139 + this._server = server; 1140 1140 } 1141 1141 } 1142 1142 1143 1143 type SharedRateLimitOpts<T> = { 1144 1144 - name: string 1145 1145 - calcKey?: (ctx: T) => string | null 1146 1146 - calcPoints?: (ctx: T) => number 1147 1147 - } 1144 1144 + name: string; 1145 1145 + calcKey?: (ctx: T) => string | null; 1146 1146 + calcPoints?: (ctx: T) => number; 1147 1147 + }; 1148 1148 type RouteRateLimitOpts<T> = { 1149 1149 - durationMs: number 1150 1150 - points: number 1151 1151 - calcKey?: (ctx: T) => string | null 1152 1152 - calcPoints?: (ctx: T) => number 1153 1153 - } 1154 1154 - type HandlerOpts = { blobLimit?: number } 1155 1155 - type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T> 1149 1149 + durationMs: number; 1150 1150 + points: number; 1151 1151 + calcKey?: (ctx: T) => string | null; 1152 1152 + calcPoints?: (ctx: T) => number; 1153 1153 + }; 1154 1154 + type HandlerOpts = { blobLimit?: number }; 1155 1155 + type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>; 1156 1156 type ConfigOf<Auth, Handler, ReqCtx> = 1157 1157 | Handler 1158 1158 | { 1159 1159 - auth?: Auth 1160 1160 - opts?: HandlerOpts 1161 1161 - rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[] 1162 1162 - handler: Handler 1163 1163 - } 1159 1159 + auth?: Auth; 1160 1160 + opts?: HandlerOpts; 1161 1161 + rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]; 1162 1162 + handler: Handler; 1163 1163 + }; 1164 1164 type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract< 1165 1165 Awaited<ReturnType<AV>>, 1166 1166 { credentials: unknown } 1167 1167 - > 1167 1167 + >;

+1869 -1849

apps/api/src/lexicon/lexicons.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type LexiconDoc, Lexicons } from '@atproto/lexicon' 4 4 + import { LexiconDoc, Lexicons } from "@atproto/lexicon"; 5 5 6 6 export const schemaDict = { 7 7 AppRockskyActorDefs: { 8 8 lexicon: 1, 9 9 - id: 'app.rocksky.actor.defs', 9 9 + id: "app.rocksky.actor.defs", 10 10 defs: { 11 11 profileViewDetailed: { 12 12 - type: 'object', 12 12 + type: "object", 13 13 properties: { 14 14 id: { 15 15 - type: 'string', 16 16 - description: 'The unique identifier of the actor.', 15 15 + type: "string", 16 16 + description: "The unique identifier of the actor.", 17 17 }, 18 18 did: { 19 19 - type: 'string', 20 20 - description: 'The DID of the actor.', 19 19 + type: "string", 20 20 + description: "The DID of the actor.", 21 21 }, 22 22 handle: { 23 23 - type: 'string', 24 24 - description: 'The handle of the actor.', 23 23 + type: "string", 24 24 + description: "The handle of the actor.", 25 25 }, 26 26 displayName: { 27 27 - type: 'string', 28 28 - description: 'The display name of the actor.', 27 27 + type: "string", 28 28 + description: "The display name of the actor.", 29 29 }, 30 30 avatar: { 31 31 - type: 'string', 31 31 + type: "string", 32 32 description: "The URL of the actor's avatar image.", 33 33 - format: 'uri', 33 33 + format: "uri", 34 34 }, 35 35 createdAt: { 36 36 - type: 'string', 37 37 - description: 'The date and time when the actor was created.', 38 38 - format: 'datetime', 36 36 + type: "string", 37 37 + description: "The date and time when the actor was created.", 38 38 + format: "datetime", 39 39 }, 40 40 updatedAt: { 41 41 - type: 'string', 42 42 - description: 'The date and time when the actor was last updated.', 43 43 - format: 'datetime', 41 41 + type: "string", 42 42 + description: "The date and time when the actor was last updated.", 43 43 + format: "datetime", 44 44 }, 45 45 }, 46 46 }, 47 47 profileViewBasic: { 48 48 - type: 'object', 48 48 + type: "object", 49 49 properties: { 50 50 id: { 51 51 - type: 'string', 52 52 - description: 'The unique identifier of the actor.', 51 51 + type: "string", 52 52 + description: "The unique identifier of the actor.", 53 53 }, 54 54 did: { 55 55 - type: 'string', 56 56 - description: 'The DID of the actor.', 55 55 + type: "string", 56 56 + description: "The DID of the actor.", 57 57 }, 58 58 handle: { 59 59 - type: 'string', 60 60 - description: 'The handle of the actor.', 59 59 + type: "string", 60 60 + description: "The handle of the actor.", 61 61 }, 62 62 displayName: { 63 63 - type: 'string', 64 64 - description: 'The display name of the actor.', 63 63 + type: "string", 64 64 + description: "The display name of the actor.", 65 65 }, 66 66 avatar: { 67 67 - type: 'string', 67 67 + type: "string", 68 68 description: "The URL of the actor's avatar image.", 69 69 - format: 'uri', 69 69 + format: "uri", 70 70 }, 71 71 createdAt: { 72 72 - type: 'string', 73 73 - description: 'The date and time when the actor was created.', 74 74 - format: 'datetime', 72 72 + type: "string", 73 73 + description: "The date and time when the actor was created.", 74 74 + format: "datetime", 75 75 }, 76 76 updatedAt: { 77 77 - type: 'string', 78 78 - description: 'The date and time when the actor was last updated.', 79 79 - format: 'datetime', 77 77 + type: "string", 78 78 + description: "The date and time when the actor was last updated.", 79 79 + format: "datetime", 80 80 }, 81 81 }, 82 82 }, ··· 84 84 }, 85 85 AppRockskyActorGetActorAlbums: { 86 86 lexicon: 1, 87 87 - id: 'app.rocksky.actor.getActorAlbums', 87 87 + id: "app.rocksky.actor.getActorAlbums", 88 88 defs: { 89 89 main: { 90 90 - type: 'query', 91 91 - description: 'Get albums for an actor', 90 90 + type: "query", 91 91 + description: "Get albums for an actor", 92 92 parameters: { 93 93 - type: 'params', 94 94 - required: ['did'], 93 93 + type: "params", 94 94 + required: ["did"], 95 95 properties: { 96 96 did: { 97 97 - type: 'string', 98 98 - description: 'The DID or handle of the actor', 99 99 - format: 'at-identifier', 97 97 + type: "string", 98 98 + description: "The DID or handle of the actor", 99 99 + format: "at-identifier", 100 100 }, 101 101 limit: { 102 102 - type: 'integer', 103 103 - description: 'The maximum number of albums to return', 102 102 + type: "integer", 103 103 + description: "The maximum number of albums to return", 104 104 minimum: 1, 105 105 }, 106 106 offset: { 107 107 - type: 'integer', 108 108 - description: 'The offset for pagination', 107 107 + type: "integer", 108 108 + description: "The offset for pagination", 109 109 minimum: 0, 110 110 }, 111 111 }, 112 112 }, 113 113 output: { 114 114 - encoding: 'application/json', 114 114 + encoding: "application/json", 115 115 schema: { 116 116 - type: 'object', 116 116 + type: "object", 117 117 properties: { 118 118 albums: { 119 119 - type: 'array', 119 119 + type: "array", 120 120 items: { 121 121 - type: 'ref', 122 122 - ref: 'lex:app.rocksky.album.defs#albumViewBasic', 121 121 + type: "ref", 122 122 + ref: "lex:app.rocksky.album.defs#albumViewBasic", 123 123 }, 124 124 }, 125 125 }, ··· 130 130 }, 131 131 AppRockskyActorGetActorArtists: { 132 132 lexicon: 1, 133 133 - id: 'app.rocksky.actor.getActorArtists', 133 133 + id: "app.rocksky.actor.getActorArtists", 134 134 defs: { 135 135 main: { 136 136 - type: 'query', 137 137 - description: 'Get artists for an actor', 136 136 + type: "query", 137 137 + description: "Get artists for an actor", 138 138 parameters: { 139 139 - type: 'params', 140 140 - required: ['did'], 139 139 + type: "params", 140 140 + required: ["did"], 141 141 properties: { 142 142 did: { 143 143 - type: 'string', 144 144 - description: 'The DID or handle of the actor', 145 145 - format: 'at-identifier', 143 143 + type: "string", 144 144 + description: "The DID or handle of the actor", 145 145 + format: "at-identifier", 146 146 }, 147 147 limit: { 148 148 - type: 'integer', 149 149 - description: 'The maximum number of albums to return', 148 148 + type: "integer", 149 149 + description: "The maximum number of albums to return", 150 150 minimum: 1, 151 151 }, 152 152 offset: { 153 153 - type: 'integer', 154 154 - description: 'The offset for pagination', 153 153 + type: "integer", 154 154 + description: "The offset for pagination", 155 155 minimum: 0, 156 156 }, 157 157 }, 158 158 }, 159 159 output: { 160 160 - encoding: 'application/json', 160 160 + encoding: "application/json", 161 161 schema: { 162 162 - type: 'object', 162 162 + type: "object", 163 163 properties: { 164 164 artists: { 165 165 - type: 'array', 165 165 + type: "array", 166 166 items: { 167 167 - type: 'ref', 168 168 - ref: 'lex:app.rocksky.artist.defs#artistViewBasic', 167 167 + type: "ref", 168 168 + ref: "lex:app.rocksky.artist.defs#artistViewBasic", 169 169 }, 170 170 }, 171 171 }, ··· 176 176 }, 177 177 AppRockskyActorGetActorLovedSongs: { 178 178 lexicon: 1, 179 179 - id: 'app.rocksky.actor.getActorLovedSongs', 179 179 + id: "app.rocksky.actor.getActorLovedSongs", 180 180 defs: { 181 181 main: { 182 182 - type: 'query', 183 183 - description: 'Get loved songs for an actor', 182 182 + type: "query", 183 183 + description: "Get loved songs for an actor", 184 184 parameters: { 185 185 - type: 'params', 186 186 - required: ['did'], 185 185 + type: "params", 186 186 + required: ["did"], 187 187 properties: { 188 188 did: { 189 189 - type: 'string', 190 190 - description: 'The DID or handle of the actor', 191 191 - format: 'at-identifier', 189 189 + type: "string", 190 190 + description: "The DID or handle of the actor", 191 191 + format: "at-identifier", 192 192 }, 193 193 limit: { 194 194 - type: 'integer', 195 195 - description: 'The maximum number of albums to return', 194 194 + type: "integer", 195 195 + description: "The maximum number of albums to return", 196 196 minimum: 1, 197 197 }, 198 198 offset: { 199 199 - type: 'integer', 200 200 - description: 'The offset for pagination', 199 199 + type: "integer", 200 200 + description: "The offset for pagination", 201 201 minimum: 0, 202 202 }, 203 203 }, 204 204 }, 205 205 output: { 206 206 - encoding: 'application/json', 206 206 + encoding: "application/json", 207 207 schema: { 208 208 - type: 'object', 208 208 + type: "object", 209 209 properties: { 210 210 tracks: { 211 211 - type: 'array', 211 211 + type: "array", 212 212 items: { 213 213 - type: 'ref', 214 214 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 213 213 + type: "ref", 214 214 + ref: "lex:app.rocksky.song.defs#songViewBasic", 215 215 }, 216 216 }, 217 217 }, ··· 222 222 }, 223 223 AppRockskyActorGetActorPlaylists: { 224 224 lexicon: 1, 225 225 - id: 'app.rocksky.actor.getActorPlaylists', 225 225 + id: "app.rocksky.actor.getActorPlaylists", 226 226 defs: { 227 227 main: { 228 228 - type: 'query', 229 229 - description: 'Get playlists for an actor', 228 228 + type: "query", 229 229 + description: "Get playlists for an actor", 230 230 parameters: { 231 231 - type: 'params', 232 232 - required: ['did'], 231 231 + type: "params", 232 232 + required: ["did"], 233 233 properties: { 234 234 did: { 235 235 - type: 'string', 236 236 - description: 'The DID or handle of the actor', 237 237 - format: 'at-identifier', 235 235 + type: "string", 236 236 + description: "The DID or handle of the actor", 237 237 + format: "at-identifier", 238 238 }, 239 239 limit: { 240 240 - type: 'integer', 241 241 - description: 'The maximum number of albums to return', 240 240 + type: "integer", 241 241 + description: "The maximum number of albums to return", 242 242 minimum: 1, 243 243 }, 244 244 offset: { 245 245 - type: 'integer', 246 246 - description: 'The offset for pagination', 245 245 + type: "integer", 246 246 + description: "The offset for pagination", 247 247 minimum: 0, 248 248 }, 249 249 }, 250 250 }, 251 251 output: { 252 252 - encoding: 'application/json', 252 252 + encoding: "application/json", 253 253 schema: { 254 254 - type: 'object', 254 254 + type: "object", 255 255 properties: { 256 256 playlists: { 257 257 - type: 'array', 257 257 + type: "array", 258 258 items: { 259 259 - type: 'ref', 260 260 - ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic', 259 259 + type: "ref", 260 260 + ref: "lex:app.rocksky.playlist.defs#playlistViewBasic", 261 261 }, 262 262 }, 263 263 }, ··· 268 268 }, 269 269 AppRockskyActorGetActorScrobbles: { 270 270 lexicon: 1, 271 271 - id: 'app.rocksky.actor.getActorScrobbles', 271 271 + id: "app.rocksky.actor.getActorScrobbles", 272 272 defs: { 273 273 main: { 274 274 - type: 'query', 275 275 - description: 'Get scrobbles for an actor', 274 274 + type: "query", 275 275 + description: "Get scrobbles for an actor", 276 276 parameters: { 277 277 - type: 'params', 278 278 - required: ['did'], 277 277 + type: "params", 278 278 + required: ["did"], 279 279 properties: { 280 280 did: { 281 281 - type: 'string', 282 282 - description: 'The DID or handle of the actor', 283 283 - format: 'at-identifier', 281 281 + type: "string", 282 282 + description: "The DID or handle of the actor", 283 283 + format: "at-identifier", 284 284 }, 285 285 limit: { 286 286 - type: 'integer', 287 287 - description: 'The maximum number of albums to return', 286 286 + type: "integer", 287 287 + description: "The maximum number of albums to return", 288 288 minimum: 1, 289 289 }, 290 290 offset: { 291 291 - type: 'integer', 292 292 - description: 'The offset for pagination', 291 291 + type: "integer", 292 292 + description: "The offset for pagination", 293 293 minimum: 0, 294 294 }, 295 295 }, 296 296 }, 297 297 output: { 298 298 - encoding: 'application/json', 298 298 + encoding: "application/json", 299 299 schema: { 300 300 - type: 'object', 300 300 + type: "object", 301 301 properties: { 302 302 scrobbles: { 303 303 - type: 'array', 303 303 + type: "array", 304 304 items: { 305 305 - type: 'ref', 306 306 - ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic', 305 305 + type: "ref", 306 306 + ref: "lex:app.rocksky.scrobble.defs#scrobbleViewBasic", 307 307 }, 308 308 }, 309 309 }, ··· 314 314 }, 315 315 AppRockskyActorGetActorSongs: { 316 316 lexicon: 1, 317 317 - id: 'app.rocksky.actor.getActorSongs', 317 317 + id: "app.rocksky.actor.getActorSongs", 318 318 defs: { 319 319 main: { 320 320 - type: 'query', 321 321 - description: 'Get songs for an actor', 320 320 + type: "query", 321 321 + description: "Get songs for an actor", 322 322 parameters: { 323 323 - type: 'params', 324 324 - required: ['did'], 323 323 + type: "params", 324 324 + required: ["did"], 325 325 properties: { 326 326 did: { 327 327 - type: 'string', 328 328 - description: 'The DID or handle of the actor', 329 329 - format: 'at-identifier', 327 327 + type: "string", 328 328 + description: "The DID or handle of the actor", 329 329 + format: "at-identifier", 330 330 }, 331 331 limit: { 332 332 - type: 'integer', 333 333 - description: 'The maximum number of albums to return', 332 332 + type: "integer", 333 333 + description: "The maximum number of albums to return", 334 334 minimum: 1, 335 335 }, 336 336 offset: { 337 337 - type: 'integer', 338 338 - description: 'The offset for pagination', 337 337 + type: "integer", 338 338 + description: "The offset for pagination", 339 339 minimum: 0, 340 340 }, 341 341 }, 342 342 }, 343 343 output: { 344 344 - encoding: 'application/json', 344 344 + encoding: "application/json", 345 345 schema: { 346 346 - type: 'object', 346 346 + type: "object", 347 347 properties: { 348 348 songs: { 349 349 - type: 'array', 349 349 + type: "array", 350 350 items: { 351 351 - type: 'ref', 352 352 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 351 351 + type: "ref", 352 352 + ref: "lex:app.rocksky.song.defs#songViewBasic", 353 353 }, 354 354 }, 355 355 }, ··· 360 360 }, 361 361 AppRockskyActorGetProfile: { 362 362 lexicon: 1, 363 363 - id: 'app.rocksky.actor.getProfile', 363 363 + id: "app.rocksky.actor.getProfile", 364 364 defs: { 365 365 main: { 366 366 - type: 'query', 367 367 - description: 'Get the profile of an actor', 366 366 + type: "query", 367 367 + description: "Get the profile of an actor", 368 368 parameters: { 369 369 - type: 'params', 369 369 + type: "params", 370 370 properties: { 371 371 did: { 372 372 - type: 'string', 373 373 - description: 'The DID or handle of the actor', 374 374 - format: 'at-identifier', 372 372 + type: "string", 373 373 + description: "The DID or handle of the actor", 374 374 + format: "at-identifier", 375 375 }, 376 376 }, 377 377 }, 378 378 output: { 379 379 - encoding: 'application/json', 379 379 + encoding: "application/json", 380 380 schema: { 381 381 - type: 'ref', 382 382 - ref: 'lex:app.rocksky.actor.defs#profileViewDetailed', 381 381 + type: "ref", 382 382 + ref: "lex:app.rocksky.actor.defs#profileViewDetailed", 383 383 }, 384 384 }, 385 385 }, ··· 387 387 }, 388 388 AppBskyActorProfile: { 389 389 lexicon: 1, 390 390 - id: 'app.bsky.actor.profile', 390 390 + id: "app.bsky.actor.profile", 391 391 defs: { 392 392 main: { 393 393 - type: 'record', 394 394 - description: 'A declaration of a Bluesky account profile.', 395 395 - key: 'literal:self', 393 393 + type: "record", 394 394 + description: "A declaration of a Bluesky account profile.", 395 395 + key: "literal:self", 396 396 record: { 397 397 - type: 'object', 397 397 + type: "object", 398 398 properties: { 399 399 displayName: { 400 400 - type: 'string', 400 400 + type: "string", 401 401 maxGraphemes: 64, 402 402 maxLength: 640, 403 403 }, 404 404 description: { 405 405 - type: 'string', 406 406 - description: 'Free-form profile description text.', 405 405 + type: "string", 406 406 + description: "Free-form profile description text.", 407 407 maxGraphemes: 256, 408 408 maxLength: 2560, 409 409 }, 410 410 avatar: { 411 411 - type: 'blob', 411 411 + type: "blob", 412 412 description: 413 413 "Small image to be displayed next to posts from account. AKA, 'profile picture'", 414 414 - accept: ['image/png', 'image/jpeg'], 414 414 + accept: ["image/png", "image/jpeg"], 415 415 maxSize: 1000000, 416 416 }, 417 417 banner: { 418 418 - type: 'blob', 418 418 + type: "blob", 419 419 description: 420 420 - 'Larger horizontal image to display behind profile view.', 421 421 - accept: ['image/png', 'image/jpeg'], 420 420 + "Larger horizontal image to display behind profile view.", 421 421 + accept: ["image/png", "image/jpeg"], 422 422 maxSize: 10000000, 423 423 }, 424 424 labels: { 425 425 - type: 'union', 425 425 + type: "union", 426 426 description: 427 427 - 'Self-label values, specific to the Bluesky application, on the overall account.', 428 428 - refs: ['lex:com.atproto.label.defs#selfLabels'], 427 427 + "Self-label values, specific to the Bluesky application, on the overall account.", 428 428 + refs: ["lex:com.atproto.label.defs#selfLabels"], 429 429 }, 430 430 joinedViaStarterPack: { 431 431 - type: 'ref', 432 432 - ref: 'lex:com.atproto.repo.strongRef', 431 431 + type: "ref", 432 432 + ref: "lex:com.atproto.repo.strongRef", 433 433 }, 434 434 createdAt: { 435 435 - type: 'string', 436 436 - format: 'datetime', 435 435 + type: "string", 436 436 + format: "datetime", 437 437 }, 438 438 }, 439 439 }, ··· 442 442 }, 443 443 AppRockskyAlbum: { 444 444 lexicon: 1, 445 445 - id: 'app.rocksky.album', 445 445 + id: "app.rocksky.album", 446 446 defs: { 447 447 main: { 448 448 - type: 'record', 449 449 - description: 'A declaration of an album.', 450 450 - key: 'tid', 448 448 + type: "record", 449 449 + description: "A declaration of an album.", 450 450 + key: "tid", 451 451 record: { 452 452 - type: 'object', 453 453 - required: ['title', 'artist', 'createdAt'], 452 452 + type: "object", 453 453 + required: ["title", "artist", "createdAt"], 454 454 properties: { 455 455 title: { 456 456 - type: 'string', 457 457 - description: 'The title of the album.', 456 456 + type: "string", 457 457 + description: "The title of the album.", 458 458 minLength: 1, 459 459 maxLength: 512, 460 460 }, 461 461 artist: { 462 462 - type: 'string', 463 463 - description: 'The artist of the album.', 462 462 + type: "string", 463 463 + description: "The artist of the album.", 464 464 minLength: 1, 465 465 maxLength: 256, 466 466 }, 467 467 duration: { 468 468 - type: 'integer', 469 469 - description: 'The duration of the album in seconds.', 468 468 + type: "integer", 469 469 + description: "The duration of the album in seconds.", 470 470 }, 471 471 releaseDate: { 472 472 - type: 'string', 473 473 - description: 'The release date of the album.', 474 474 - format: 'datetime', 472 472 + type: "string", 473 473 + description: "The release date of the album.", 474 474 + format: "datetime", 475 475 }, 476 476 year: { 477 477 - type: 'integer', 478 478 - description: 'The year the album was released.', 477 477 + type: "integer", 478 478 + description: "The year the album was released.", 479 479 }, 480 480 genre: { 481 481 - type: 'string', 482 482 - description: 'The genre of the album.', 481 481 + type: "string", 482 482 + description: "The genre of the album.", 483 483 maxLength: 256, 484 484 }, 485 485 albumArt: { 486 486 - type: 'blob', 487 487 - description: 'The album art of the album.', 488 488 - accept: ['image/png', 'image/jpeg'], 486 486 + type: "blob", 487 487 + description: "The album art of the album.", 488 488 + accept: ["image/png", "image/jpeg"], 489 489 maxSize: 2000000, 490 490 }, 491 491 + albumArtUrl: { 492 492 + type: "string", 493 493 + description: "The URL of the album art of the album.", 494 494 + format: "uri", 495 495 + }, 491 496 tags: { 492 492 - type: 'array', 493 493 - description: 'The tags of the album.', 497 497 + type: "array", 498 498 + description: "The tags of the album.", 494 499 items: { 495 495 - type: 'string', 500 500 + type: "string", 496 501 minLength: 1, 497 502 maxLength: 256, 498 503 }, 499 504 }, 500 505 youtubeLink: { 501 501 - type: 'string', 502 502 - description: 'The YouTube link of the album.', 503 503 - format: 'uri', 506 506 + type: "string", 507 507 + description: "The YouTube link of the album.", 508 508 + format: "uri", 504 509 }, 505 510 spotifyLink: { 506 506 - type: 'string', 507 507 - description: 'The Spotify link of the album.', 508 508 - format: 'uri', 511 511 + type: "string", 512 512 + description: "The Spotify link of the album.", 513 513 + format: "uri", 509 514 }, 510 515 tidalLink: { 511 511 - type: 'string', 512 512 - description: 'The tidal link of the album.', 513 513 - format: 'uri', 516 516 + type: "string", 517 517 + description: "The tidal link of the album.", 518 518 + format: "uri", 514 519 }, 515 520 appleMusicLink: { 516 516 - type: 'string', 517 517 - description: 'The Apple Music link of the album.', 518 518 - format: 'uri', 521 521 + type: "string", 522 522 + description: "The Apple Music link of the album.", 523 523 + format: "uri", 519 524 }, 520 525 createdAt: { 521 521 - type: 'string', 522 522 - description: 'The date and time when the album was created.', 523 523 - format: 'datetime', 526 526 + type: "string", 527 527 + description: "The date and time when the album was created.", 528 528 + format: "datetime", 524 529 }, 525 530 }, 526 531 }, ··· 529 534 }, 530 535 AppRockskyAlbumDefs: { 531 536 lexicon: 1, 532 532 - id: 'app.rocksky.album.defs', 537 537 + id: "app.rocksky.album.defs", 533 538 defs: { 534 539 albumViewBasic: { 535 535 - type: 'object', 540 540 + type: "object", 536 541 properties: { 537 542 id: { 538 538 - type: 'string', 539 539 - description: 'The unique identifier of the album.', 543 543 + type: "string", 544 544 + description: "The unique identifier of the album.", 540 545 }, 541 546 uri: { 542 542 - type: 'string', 543 543 - description: 'The URI of the album.', 544 544 - format: 'at-uri', 547 547 + type: "string", 548 548 + description: "The URI of the album.", 549 549 + format: "at-uri", 545 550 }, 546 551 title: { 547 547 - type: 'string', 548 548 - description: 'The title of the album.', 552 552 + type: "string", 553 553 + description: "The title of the album.", 549 554 }, 550 555 artist: { 551 551 - type: 'string', 552 552 - description: 'The artist of the album.', 556 556 + type: "string", 557 557 + description: "The artist of the album.", 553 558 }, 554 559 artistUri: { 555 555 - type: 'string', 560 560 + type: "string", 556 561 description: "The URI of the album's artist.", 557 557 - format: 'at-uri', 562 562 + format: "at-uri", 558 563 }, 559 564 year: { 560 560 - type: 'integer', 561 561 - description: 'The year the album was released.', 565 565 + type: "integer", 566 566 + description: "The year the album was released.", 562 567 }, 563 568 albumArt: { 564 564 - type: 'string', 565 565 - description: 'The URL of the album art image.', 566 566 - format: 'uri', 569 569 + type: "string", 570 570 + description: "The URL of the album art image.", 571 571 + format: "uri", 567 572 }, 568 573 releaseDate: { 569 569 - type: 'string', 570 570 - description: 'The release date of the album.', 574 574 + type: "string", 575 575 + description: "The release date of the album.", 571 576 }, 572 577 sha256: { 573 573 - type: 'string', 574 574 - description: 'The SHA256 hash of the album.', 578 578 + type: "string", 579 579 + description: "The SHA256 hash of the album.", 575 580 }, 576 581 playCount: { 577 577 - type: 'integer', 578 578 - description: 'The number of times the album has been played.', 582 582 + type: "integer", 583 583 + description: "The number of times the album has been played.", 579 584 minimum: 0, 580 585 }, 581 586 uniqueListeners: { 582 582 - type: 'integer', 587 587 + type: "integer", 583 588 description: 584 584 - 'The number of unique listeners who have played the album.', 589 589 + "The number of unique listeners who have played the album.", 585 590 minimum: 0, 586 591 }, 587 592 }, 588 593 }, 589 594 albumViewDetailed: { 590 590 - type: 'object', 595 595 + type: "object", 591 596 properties: { 592 597 id: { 593 593 - type: 'string', 594 594 - description: 'The unique identifier of the album.', 598 598 + type: "string", 599 599 + description: "The unique identifier of the album.", 595 600 }, 596 601 uri: { 597 597 - type: 'string', 598 598 - description: 'The URI of the album.', 599 599 - format: 'at-uri', 602 602 + type: "string", 603 603 + description: "The URI of the album.", 604 604 + format: "at-uri", 600 605 }, 601 606 title: { 602 602 - type: 'string', 603 603 - description: 'The title of the album.', 607 607 + type: "string", 608 608 + description: "The title of the album.", 604 609 }, 605 610 artist: { 606 606 - type: 'string', 607 607 - description: 'The artist of the album.', 611 611 + type: "string", 612 612 + description: "The artist of the album.", 608 613 }, 609 614 artistUri: { 610 610 - type: 'string', 615 615 + type: "string", 611 616 description: "The URI of the album's artist.", 612 612 - format: 'at-uri', 617 617 + format: "at-uri", 613 618 }, 614 619 year: { 615 615 - type: 'integer', 616 616 - description: 'The year the album was released.', 620 620 + type: "integer", 621 621 + description: "The year the album was released.", 617 622 }, 618 623 albumArt: { 619 619 - type: 'string', 620 620 - description: 'The URL of the album art image.', 621 621 - format: 'uri', 624 624 + type: "string", 625 625 + description: "The URL of the album art image.", 626 626 + format: "uri", 622 627 }, 623 628 releaseDate: { 624 624 - type: 'string', 625 625 - description: 'The release date of the album.', 629 629 + type: "string", 630 630 + description: "The release date of the album.", 626 631 }, 627 632 sha256: { 628 628 - type: 'string', 629 629 - description: 'The SHA256 hash of the album.', 633 633 + type: "string", 634 634 + description: "The SHA256 hash of the album.", 630 635 }, 631 636 playCount: { 632 632 - type: 'integer', 633 633 - description: 'The number of times the album has been played.', 637 637 + type: "integer", 638 638 + description: "The number of times the album has been played.", 634 639 minimum: 0, 635 640 }, 636 641 uniqueListeners: { 637 637 - type: 'integer', 642 642 + type: "integer", 638 643 description: 639 639 - 'The number of unique listeners who have played the album.', 644 644 + "The number of unique listeners who have played the album.", 640 645 minimum: 0, 641 646 }, 642 647 tracks: { 643 643 - type: 'array', 648 648 + type: "array", 644 649 items: { 645 645 - type: 'ref', 646 646 - ref: 'lex:app.rocksky.song.defs.songViewBasic', 650 650 + type: "ref", 651 651 + ref: "lex:app.rocksky.song.defs.songViewBasic", 647 652 }, 648 653 }, 649 654 }, ··· 652 657 }, 653 658 AppRockskyAlbumGetAlbum: { 654 659 lexicon: 1, 655 655 - id: 'app.rocksky.album.getAlbum', 660 660 + id: "app.rocksky.album.getAlbum", 656 661 defs: { 657 662 main: { 658 658 - type: 'query', 659 659 - description: 'Get detailed album view', 663 663 + type: "query", 664 664 + description: "Get detailed album view", 660 665 parameters: { 661 661 - type: 'params', 662 662 - required: ['uri'], 666 666 + type: "params", 667 667 + required: ["uri"], 663 668 properties: { 664 669 uri: { 665 665 - type: 'string', 666 666 - description: 'The URI of the album to retrieve.', 667 667 - format: 'at-uri', 670 670 + type: "string", 671 671 + description: "The URI of the album to retrieve.", 672 672 + format: "at-uri", 668 673 }, 669 674 }, 670 675 }, 671 676 output: { 672 672 - encoding: 'application/json', 677 677 + encoding: "application/json", 673 678 schema: { 674 674 - type: 'ref', 675 675 - ref: 'lex:app.rocksky.album.defs#albumViewDetailed', 679 679 + type: "ref", 680 680 + ref: "lex:app.rocksky.album.defs#albumViewDetailed", 676 681 }, 677 682 }, 678 683 }, ··· 680 685 }, 681 686 AppRockskyAlbumGetAlbums: { 682 687 lexicon: 1, 683 683 - id: 'app.rocksky.album.getAlbums', 688 688 + id: "app.rocksky.album.getAlbums", 684 689 defs: { 685 690 main: { 686 686 - type: 'query', 687 687 - description: 'Get albums', 691 691 + type: "query", 692 692 + description: "Get albums", 688 693 parameters: { 689 689 - type: 'params', 694 694 + type: "params", 690 695 properties: { 691 696 limit: { 692 692 - type: 'integer', 693 693 - description: 'The maximum number of albums to return', 697 697 + type: "integer", 698 698 + description: "The maximum number of albums to return", 694 699 minimum: 1, 695 700 }, 696 701 offset: { 697 697 - type: 'integer', 698 698 - description: 'The offset for pagination', 702 702 + type: "integer", 703 703 + description: "The offset for pagination", 699 704 minimum: 0, 700 705 }, 701 706 }, 702 707 }, 703 708 output: { 704 704 - encoding: 'application/json', 709 709 + encoding: "application/json", 705 710 schema: { 706 706 - type: 'object', 711 711 + type: "object", 707 712 properties: { 708 713 albums: { 709 709 - type: 'array', 714 714 + type: "array", 710 715 items: { 711 711 - type: 'ref', 712 712 - ref: 'lex:app.rocksky.album.defs#albumViewBasic', 716 716 + type: "ref", 717 717 + ref: "lex:app.rocksky.album.defs#albumViewBasic", 713 718 }, 714 719 }, 715 720 }, ··· 720 725 }, 721 726 AppRockskyAlbumGetAlbumTracks: { 722 727 lexicon: 1, 723 723 - id: 'app.rocksky.album.getAlbumTracks', 728 728 + id: "app.rocksky.album.getAlbumTracks", 724 729 defs: { 725 730 main: { 726 726 - type: 'query', 727 727 - description: 'Get tracks for an album', 731 731 + type: "query", 732 732 + description: "Get tracks for an album", 728 733 parameters: { 729 729 - type: 'params', 730 730 - required: ['uri'], 734 734 + type: "params", 735 735 + required: ["uri"], 731 736 properties: { 732 737 uri: { 733 733 - type: 'string', 734 734 - description: 'The URI of the album to retrieve tracks from', 735 735 - format: 'at-uri', 738 738 + type: "string", 739 739 + description: "The URI of the album to retrieve tracks from", 740 740 + format: "at-uri", 736 741 }, 737 742 }, 738 743 }, 739 744 output: { 740 740 - encoding: 'application/json', 745 745 + encoding: "application/json", 741 746 schema: { 742 742 - type: 'object', 747 747 + type: "object", 743 748 properties: { 744 749 tracks: { 745 745 - type: 'array', 750 750 + type: "array", 746 751 items: { 747 747 - type: 'ref', 748 748 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 752 752 + type: "ref", 753 753 + ref: "lex:app.rocksky.song.defs#songViewBasic", 749 754 }, 750 755 }, 751 756 }, ··· 756 761 }, 757 762 AppRockskyApikeyCreateApikey: { 758 763 lexicon: 1, 759 759 - id: 'app.rocksky.apikey.createApikey', 764 764 + id: "app.rocksky.apikey.createApikey", 760 765 defs: { 761 766 main: { 762 762 - type: 'procedure', 763 763 - description: 'Create a new API key for the authenticated user', 767 767 + type: "procedure", 768 768 + description: "Create a new API key for the authenticated user", 764 769 input: { 765 765 - encoding: 'application/json', 770 770 + encoding: "application/json", 766 771 schema: { 767 767 - type: 'object', 768 768 - required: ['name'], 772 772 + type: "object", 773 773 + required: ["name"], 769 774 properties: { 770 775 name: { 771 771 - type: 'string', 772 772 - description: 'The name of the API key.', 776 776 + type: "string", 777 777 + description: "The name of the API key.", 773 778 }, 774 779 description: { 775 775 - type: 'string', 776 776 - description: 'A description for the API key.', 780 780 + type: "string", 781 781 + description: "A description for the API key.", 777 782 }, 778 783 }, 779 784 }, 780 785 }, 781 786 output: { 782 782 - encoding: 'application/json', 787 787 + encoding: "application/json", 783 788 schema: { 784 784 - type: 'ref', 785 785 - ref: 'lex:app.rocksky.apikey.defs#apiKey', 789 789 + type: "ref", 790 790 + ref: "lex:app.rocksky.apikey.defs#apiKey", 786 791 }, 787 792 }, 788 793 }, ··· 790 795 }, 791 796 AppRockskyApikeyDefs: { 792 797 lexicon: 1, 793 793 - id: 'app.rocksky.apikey.defs', 798 798 + id: "app.rocksky.apikey.defs", 794 799 defs: { 795 800 apiKeyView: { 796 796 - type: 'object', 801 801 + type: "object", 797 802 properties: { 798 803 id: { 799 799 - type: 'string', 800 800 - description: 'The unique identifier of the API key.', 804 804 + type: "string", 805 805 + description: "The unique identifier of the API key.", 801 806 }, 802 807 name: { 803 803 - type: 'string', 804 804 - description: 'The name of the API key.', 808 808 + type: "string", 809 809 + description: "The name of the API key.", 805 810 }, 806 811 description: { 807 807 - type: 'string', 808 808 - description: 'A description for the API key.', 812 812 + type: "string", 813 813 + description: "A description for the API key.", 809 814 }, 810 815 createdAt: { 811 811 - type: 'string', 812 812 - description: 'The date and time when the API key was created.', 813 813 - format: 'datetime', 816 816 + type: "string", 817 817 + description: "The date and time when the API key was created.", 818 818 + format: "datetime", 814 819 }, 815 820 }, 816 821 }, ··· 818 823 }, 819 824 AppRockskyApikeysDefs: { 820 825 lexicon: 1, 821 821 - id: 'app.rocksky.apikeys.defs', 826 826 + id: "app.rocksky.apikeys.defs", 822 827 defs: {}, 823 828 }, 824 829 AppRockskyApikeyGetApikeys: { 825 830 lexicon: 1, 826 826 - id: 'app.rocksky.apikey.getApikeys', 831 831 + id: "app.rocksky.apikey.getApikeys", 827 832 defs: { 828 833 main: { 829 829 - type: 'query', 830 830 - description: 'Get a list of API keys for the authenticated user', 834 834 + type: "query", 835 835 + description: "Get a list of API keys for the authenticated user", 831 836 parameters: { 832 832 - type: 'params', 837 837 + type: "params", 833 838 properties: { 834 839 offset: { 835 835 - type: 'integer', 840 840 + type: "integer", 836 841 description: 837 837 - 'The number of API keys to skip before starting to collect the result set.', 842 842 + "The number of API keys to skip before starting to collect the result set.", 838 843 }, 839 844 limit: { 840 840 - type: 'integer', 841 841 - description: 'The number of API keys to return per page.', 845 845 + type: "integer", 846 846 + description: "The number of API keys to return per page.", 842 847 }, 843 848 }, 844 849 }, 845 850 output: { 846 846 - encoding: 'application/json', 851 851 + encoding: "application/json", 847 852 schema: { 848 848 - type: 'object', 853 853 + type: "object", 849 854 properties: { 850 855 apiKeys: { 851 851 - type: 'array', 856 856 + type: "array", 852 857 items: { 853 853 - type: 'ref', 854 854 - ref: 'lex:app.rocksky.apikey.defs#apikeyView', 858 858 + type: "ref", 859 859 + ref: "lex:app.rocksky.apikey.defs#apikeyView", 855 860 }, 856 861 }, 857 862 }, ··· 862 867 }, 863 868 AppRockskyApikeyRemoveApikey: { 864 869 lexicon: 1, 865 865 - id: 'app.rocksky.apikey.removeApikey', 870 870 + id: "app.rocksky.apikey.removeApikey", 866 871 defs: { 867 872 main: { 868 868 - type: 'procedure', 869 869 - description: 'Remove an API key for the authenticated user', 873 873 + type: "procedure", 874 874 + description: "Remove an API key for the authenticated user", 870 875 parameters: { 871 871 - type: 'params', 872 872 - required: ['id'], 876 876 + type: "params", 877 877 + required: ["id"], 873 878 properties: { 874 879 id: { 875 875 - type: 'string', 876 876 - description: 'The ID of the API key to remove.', 880 880 + type: "string", 881 881 + description: "The ID of the API key to remove.", 877 882 }, 878 883 }, 879 884 }, 880 885 output: { 881 881 - encoding: 'application/json', 886 886 + encoding: "application/json", 882 887 schema: { 883 883 - type: 'ref', 884 884 - ref: 'lex:app.rocksky.apikey.defs#apiKey', 888 888 + type: "ref", 889 889 + ref: "lex:app.rocksky.apikey.defs#apiKey", 885 890 }, 886 891 }, 887 892 }, ··· 889 894 }, 890 895 AppRockskyApikeyUpdateApikey: { 891 896 lexicon: 1, 892 892 - id: 'app.rocksky.apikey.updateApikey', 897 897 + id: "app.rocksky.apikey.updateApikey", 893 898 defs: { 894 899 main: { 895 895 - type: 'procedure', 896 896 - description: 'Update an existing API key for the authenticated user', 900 900 + type: "procedure", 901 901 + description: "Update an existing API key for the authenticated user", 897 902 input: { 898 898 - encoding: 'application/json', 903 903 + encoding: "application/json", 899 904 schema: { 900 900 - type: 'object', 901 901 - required: ['id', 'name'], 905 905 + type: "object", 906 906 + required: ["id", "name"], 902 907 properties: { 903 908 id: { 904 904 - type: 'string', 905 905 - description: 'The ID of the API key to update.', 909 909 + type: "string", 910 910 + description: "The ID of the API key to update.", 906 911 }, 907 912 name: { 908 908 - type: 'string', 909 909 - description: 'The new name of the API key.', 913 913 + type: "string", 914 914 + description: "The new name of the API key.", 910 915 }, 911 916 description: { 912 912 - type: 'string', 913 913 - description: 'A new description for the API key.', 917 917 + type: "string", 918 918 + description: "A new description for the API key.", 914 919 }, 915 920 }, 916 921 }, 917 922 }, 918 923 output: { 919 919 - encoding: 'application/json', 924 924 + encoding: "application/json", 920 925 schema: { 921 921 - type: 'ref', 922 922 - ref: 'lex:app.rocksky.apikey.defs#apiKey', 926 926 + type: "ref", 927 927 + ref: "lex:app.rocksky.apikey.defs#apiKey", 923 928 }, 924 929 }, 925 930 }, ··· 927 932 }, 928 933 AppRockskyArtist: { 929 934 lexicon: 1, 930 930 - id: 'app.rocksky.artist', 935 935 + id: "app.rocksky.artist", 931 936 defs: { 932 937 main: { 933 933 - type: 'record', 934 934 - description: 'A declaration of an artist.', 935 935 - key: 'tid', 938 938 + type: "record", 939 939 + description: "A declaration of an artist.", 940 940 + key: "tid", 936 941 record: { 937 937 - type: 'object', 938 938 - required: ['name', 'createdAt'], 942 942 + type: "object", 943 943 + required: ["name", "createdAt"], 939 944 properties: { 940 945 name: { 941 941 - type: 'string', 942 942 - description: 'The name of the artist.', 946 946 + type: "string", 947 947 + description: "The name of the artist.", 943 948 minLength: 1, 944 949 maxLength: 512, 945 950 }, 946 951 bio: { 947 947 - type: 'string', 948 948 - description: 'The biography of the artist.', 952 952 + type: "string", 953 953 + description: "The biography of the artist.", 949 954 maxLength: 1000, 950 955 }, 951 956 picture: { 952 952 - type: 'blob', 953 953 - description: 'The picture of the artist.', 954 954 - accept: ['image/png', 'image/jpeg'], 957 957 + type: "blob", 958 958 + description: "The picture of the artist.", 959 959 + accept: ["image/png", "image/jpeg"], 955 960 maxSize: 2000000, 956 961 }, 962 962 + pictureUrl: { 963 963 + type: "string", 964 964 + description: "The URL of the picture of the artist.", 965 965 + format: "uri", 966 966 + }, 957 967 tags: { 958 958 - type: 'array', 959 959 - description: 'The tags of the artist.', 968 968 + type: "array", 969 969 + description: "The tags of the artist.", 960 970 items: { 961 961 - type: 'string', 971 971 + type: "string", 962 972 minLength: 1, 963 973 maxLength: 256, 964 974 }, 965 975 }, 966 976 born: { 967 967 - type: 'string', 968 968 - description: 'The birth date of the artist.', 969 969 - format: 'datetime', 977 977 + type: "string", 978 978 + description: "The birth date of the artist.", 979 979 + format: "datetime", 970 980 }, 971 981 died: { 972 972 - type: 'string', 973 973 - description: 'The death date of the artist.', 974 974 - format: 'datetime', 982 982 + type: "string", 983 983 + description: "The death date of the artist.", 984 984 + format: "datetime", 975 985 }, 976 986 bornIn: { 977 977 - type: 'string', 978 978 - description: 'The birth place of the artist.', 987 987 + type: "string", 988 988 + description: "The birth place of the artist.", 979 989 maxLength: 256, 980 990 }, 981 991 createdAt: { 982 982 - type: 'string', 983 983 - description: 'The date when the artist was created.', 984 984 - format: 'datetime', 992 992 + type: "string", 993 993 + description: "The date when the artist was created.", 994 994 + format: "datetime", 985 995 }, 986 996 }, 987 997 }, ··· 990 1000 }, 991 1001 AppRockskyArtistDefs: { 992 1002 lexicon: 1, 993 993 - id: 'app.rocksky.artist.defs', 1003 1003 + id: "app.rocksky.artist.defs", 994 1004 defs: { 995 1005 artistViewBasic: { 996 996 - type: 'object', 1006 1006 + type: "object", 997 1007 properties: { 998 1008 id: { 999 999 - type: 'string', 1000 1000 - description: 'The unique identifier of the artist.', 1009 1009 + type: "string", 1010 1010 + description: "The unique identifier of the artist.", 1001 1011 }, 1002 1012 uri: { 1003 1003 - type: 'string', 1004 1004 - description: 'The URI of the artist.', 1005 1005 - format: 'at-uri', 1013 1013 + type: "string", 1014 1014 + description: "The URI of the artist.", 1015 1015 + format: "at-uri", 1006 1016 }, 1007 1017 name: { 1008 1008 - type: 'string', 1009 1009 - description: 'The name of the artist.', 1018 1018 + type: "string", 1019 1019 + description: "The name of the artist.", 1010 1020 }, 1011 1021 picture: { 1012 1012 - type: 'string', 1013 1013 - description: 'The picture of the artist.', 1022 1022 + type: "string", 1023 1023 + description: "The picture of the artist.", 1014 1024 }, 1015 1025 sha256: { 1016 1016 - type: 'string', 1017 1017 - description: 'The SHA256 hash of the artist.', 1026 1026 + type: "string", 1027 1027 + description: "The SHA256 hash of the artist.", 1018 1028 }, 1019 1029 playCount: { 1020 1020 - type: 'integer', 1021 1021 - description: 'The number of times the artist has been played.', 1030 1030 + type: "integer", 1031 1031 + description: "The number of times the artist has been played.", 1022 1032 minimum: 0, 1023 1033 }, 1024 1034 uniqueListeners: { 1025 1025 - type: 'integer', 1035 1035 + type: "integer", 1026 1036 description: 1027 1027 - 'The number of unique listeners who have played the artist.', 1037 1037 + "The number of unique listeners who have played the artist.", 1028 1038 minimum: 0, 1029 1039 }, 1030 1040 }, 1031 1041 }, 1032 1042 artistViewDetailed: { 1033 1033 - type: 'object', 1043 1043 + type: "object", 1034 1044 properties: { 1035 1045 id: { 1036 1036 - type: 'string', 1037 1037 - description: 'The unique identifier of the artist.', 1046 1046 + type: "string", 1047 1047 + description: "The unique identifier of the artist.", 1038 1048 }, 1039 1049 uri: { 1040 1040 - type: 'string', 1041 1041 - description: 'The URI of the artist.', 1042 1042 - format: 'at-uri', 1050 1050 + type: "string", 1051 1051 + description: "The URI of the artist.", 1052 1052 + format: "at-uri", 1043 1053 }, 1044 1054 name: { 1045 1045 - type: 'string', 1046 1046 - description: 'The name of the artist.', 1055 1055 + type: "string", 1056 1056 + description: "The name of the artist.", 1047 1057 }, 1048 1058 picture: { 1049 1049 - type: 'string', 1050 1050 - description: 'The picture of the artist.', 1059 1059 + type: "string", 1060 1060 + description: "The picture of the artist.", 1051 1061 }, 1052 1062 sha256: { 1053 1053 - type: 'string', 1054 1054 - description: 'The SHA256 hash of the artist.', 1063 1063 + type: "string", 1064 1064 + description: "The SHA256 hash of the artist.", 1055 1065 }, 1056 1066 playCount: { 1057 1057 - type: 'integer', 1058 1058 - description: 'The number of times the artist has been played.', 1067 1067 + type: "integer", 1068 1068 + description: "The number of times the artist has been played.", 1059 1069 minimum: 0, 1060 1070 }, 1061 1071 uniqueListeners: { 1062 1062 - type: 'integer', 1072 1072 + type: "integer", 1063 1073 description: 1064 1064 - 'The number of unique listeners who have played the artist.', 1074 1074 + "The number of unique listeners who have played the artist.", 1065 1075 minimum: 0, 1066 1076 }, 1067 1077 }, 1068 1078 }, 1069 1079 songViewBasic: { 1070 1070 - type: 'object', 1080 1080 + type: "object", 1071 1081 properties: { 1072 1082 uri: { 1073 1073 - type: 'string', 1074 1074 - description: 'The URI of the song.', 1075 1075 - format: 'at-uri', 1083 1083 + type: "string", 1084 1084 + description: "The URI of the song.", 1085 1085 + format: "at-uri", 1076 1086 }, 1077 1087 title: { 1078 1078 - type: 'string', 1079 1079 - description: 'The title of the song.', 1088 1088 + type: "string", 1089 1089 + description: "The title of the song.", 1080 1090 }, 1081 1091 playCount: { 1082 1082 - type: 'integer', 1083 1083 - description: 'The number of times the song has been played.', 1092 1092 + type: "integer", 1093 1093 + description: "The number of times the song has been played.", 1084 1094 minimum: 0, 1085 1095 }, 1086 1096 }, 1087 1097 }, 1088 1098 listenerViewBasic: { 1089 1089 - type: 'object', 1099 1099 + type: "object", 1090 1100 properties: { 1091 1101 id: { 1092 1092 - type: 'string', 1093 1093 - description: 'The unique identifier of the actor.', 1102 1102 + type: "string", 1103 1103 + description: "The unique identifier of the actor.", 1094 1104 }, 1095 1105 did: { 1096 1096 - type: 'string', 1097 1097 - description: 'The DID of the listener.', 1106 1106 + type: "string", 1107 1107 + description: "The DID of the listener.", 1098 1108 }, 1099 1109 handle: { 1100 1100 - type: 'string', 1101 1101 - description: 'The handle of the listener.', 1110 1110 + type: "string", 1111 1111 + description: "The handle of the listener.", 1102 1112 }, 1103 1113 displayName: { 1104 1104 - type: 'string', 1105 1105 - description: 'The display name of the listener.', 1114 1114 + type: "string", 1115 1115 + description: "The display name of the listener.", 1106 1116 }, 1107 1117 avatar: { 1108 1108 - type: 'string', 1118 1118 + type: "string", 1109 1119 description: "The URL of the listener's avatar image.", 1110 1110 - format: 'uri', 1120 1120 + format: "uri", 1111 1121 }, 1112 1122 mostListenedSong: { 1113 1113 - type: 'ref', 1114 1114 - ref: 'lex:app.rocksky.artist.defs#songViewBasic', 1123 1123 + type: "ref", 1124 1124 + ref: "lex:app.rocksky.artist.defs#songViewBasic", 1115 1125 }, 1116 1126 totalPlays: { 1117 1117 - type: 'integer', 1118 1118 - description: 'The total number of plays by the listener.', 1127 1127 + type: "integer", 1128 1128 + description: "The total number of plays by the listener.", 1119 1129 minimum: 0, 1120 1130 }, 1121 1131 rank: { 1122 1122 - type: 'integer', 1132 1132 + type: "integer", 1123 1133 description: 1124 1124 - 'The rank of the listener among all listeners of the artist.', 1134 1134 + "The rank of the listener among all listeners of the artist.", 1125 1135 minimum: 1, 1126 1136 }, 1127 1137 }, ··· 1130 1140 }, 1131 1141 AppRockskyArtistGetArtistAlbums: { 1132 1142 lexicon: 1, 1133 1133 - id: 'app.rocksky.artist.getArtistAlbums', 1143 1143 + id: "app.rocksky.artist.getArtistAlbums", 1134 1144 defs: { 1135 1145 main: { 1136 1136 - type: 'query', 1146 1146 + type: "query", 1137 1147 description: "Get artist's albums", 1138 1148 parameters: { 1139 1139 - type: 'params', 1140 1140 - required: ['uri'], 1149 1149 + type: "params", 1150 1150 + required: ["uri"], 1141 1151 properties: { 1142 1152 uri: { 1143 1143 - type: 'string', 1144 1144 - description: 'The URI of the artist to retrieve albums from', 1145 1145 - format: 'at-uri', 1153 1153 + type: "string", 1154 1154 + description: "The URI of the artist to retrieve albums from", 1155 1155 + format: "at-uri", 1146 1156 }, 1147 1157 }, 1148 1158 }, 1149 1159 output: { 1150 1150 - encoding: 'application/json', 1160 1160 + encoding: "application/json", 1151 1161 schema: { 1152 1152 - type: 'object', 1162 1162 + type: "object", 1153 1163 properties: { 1154 1164 albums: { 1155 1155 - type: 'array', 1165 1165 + type: "array", 1156 1166 items: { 1157 1157 - type: 'ref', 1158 1158 - ref: 'lex:app.rocksky.album.defs#albumViewBasic', 1167 1167 + type: "ref", 1168 1168 + ref: "lex:app.rocksky.album.defs#albumViewBasic", 1159 1169 }, 1160 1170 }, 1161 1171 }, ··· 1166 1176 }, 1167 1177 AppRockskyArtistGetArtist: { 1168 1178 lexicon: 1, 1169 1169 - id: 'app.rocksky.artist.getArtist', 1179 1179 + id: "app.rocksky.artist.getArtist", 1170 1180 defs: { 1171 1181 main: { 1172 1172 - type: 'query', 1173 1173 - description: 'Get artist details', 1182 1182 + type: "query", 1183 1183 + description: "Get artist details", 1174 1184 parameters: { 1175 1175 - type: 'params', 1176 1176 - required: ['uri'], 1185 1185 + type: "params", 1186 1186 + required: ["uri"], 1177 1187 properties: { 1178 1188 uri: { 1179 1179 - type: 'string', 1180 1180 - description: 'The URI of the artist to retrieve details from', 1181 1181 - format: 'at-uri', 1189 1189 + type: "string", 1190 1190 + description: "The URI of the artist to retrieve details from", 1191 1191 + format: "at-uri", 1182 1192 }, 1183 1193 }, 1184 1194 }, 1185 1195 output: { 1186 1186 - encoding: 'application/json', 1196 1196 + encoding: "application/json", 1187 1197 schema: { 1188 1188 - type: 'ref', 1189 1189 - ref: 'lex:app.rocksky.artist.defs#artistViewDetailed', 1198 1198 + type: "ref", 1199 1199 + ref: "lex:app.rocksky.artist.defs#artistViewDetailed", 1190 1200 }, 1191 1201 }, 1192 1202 }, ··· 1194 1204 }, 1195 1205 AppRockskyArtistGetArtistListeners: { 1196 1206 lexicon: 1, 1197 1197 - id: 'app.rocksky.artist.getArtistListeners', 1207 1207 + id: "app.rocksky.artist.getArtistListeners", 1198 1208 defs: { 1199 1209 main: { 1200 1200 - type: 'query', 1201 1201 - description: 'Get artist listeners', 1210 1210 + type: "query", 1211 1211 + description: "Get artist listeners", 1202 1212 parameters: { 1203 1203 - type: 'params', 1204 1204 - required: ['uri'], 1213 1213 + type: "params", 1214 1214 + required: ["uri"], 1205 1215 properties: { 1206 1216 uri: { 1207 1207 - type: 'string', 1208 1208 - description: 'The URI of the artist to retrieve listeners from', 1209 1209 - format: 'at-uri', 1217 1217 + type: "string", 1218 1218 + description: "The URI of the artist to retrieve listeners from", 1219 1219 + format: "at-uri", 1210 1220 }, 1211 1221 offset: { 1212 1212 - type: 'integer', 1213 1213 - description: 'Number of items to skip before returning results', 1222 1222 + type: "integer", 1223 1223 + description: "Number of items to skip before returning results", 1214 1224 }, 1215 1225 limit: { 1216 1216 - type: 'integer', 1217 1217 - description: 'Maximum number of results to return', 1226 1226 + type: "integer", 1227 1227 + description: "Maximum number of results to return", 1218 1228 }, 1219 1229 }, 1220 1230 }, 1221 1231 output: { 1222 1222 - encoding: 'application/json', 1232 1232 + encoding: "application/json", 1223 1233 schema: { 1224 1224 - type: 'object', 1234 1234 + type: "object", 1225 1235 properties: { 1226 1236 listeners: { 1227 1227 - type: 'array', 1237 1237 + type: "array", 1228 1238 items: { 1229 1229 - type: 'ref', 1230 1230 - ref: 'lex:app.rocksky.artist.defs#listenerViewBasic', 1239 1239 + type: "ref", 1240 1240 + ref: "lex:app.rocksky.artist.defs#listenerViewBasic", 1231 1241 }, 1232 1242 }, 1233 1243 }, ··· 1238 1248 }, 1239 1249 AppRockskyArtistGetArtists: { 1240 1250 lexicon: 1, 1241 1241 - id: 'app.rocksky.artist.getArtists', 1251 1251 + id: "app.rocksky.artist.getArtists", 1242 1252 defs: { 1243 1253 main: { 1244 1244 - type: 'query', 1245 1245 - description: 'Get artists', 1254 1254 + type: "query", 1255 1255 + description: "Get artists", 1246 1256 parameters: { 1247 1247 - type: 'params', 1257 1257 + type: "params", 1248 1258 properties: { 1249 1259 limit: { 1250 1250 - type: 'integer', 1251 1251 - description: 'The maximum number of artists to return', 1260 1260 + type: "integer", 1261 1261 + description: "The maximum number of artists to return", 1252 1262 minimum: 1, 1253 1263 }, 1254 1264 offset: { 1255 1255 - type: 'integer', 1256 1256 - description: 'The offset for pagination', 1265 1265 + type: "integer", 1266 1266 + description: "The offset for pagination", 1257 1267 minimum: 0, 1258 1268 }, 1259 1269 }, 1260 1270 }, 1261 1271 output: { 1262 1262 - encoding: 'application/json', 1272 1272 + encoding: "application/json", 1263 1273 schema: { 1264 1264 - type: 'object', 1274 1274 + type: "object", 1265 1275 properties: { 1266 1276 artists: { 1267 1267 - type: 'array', 1277 1277 + type: "array", 1268 1278 items: { 1269 1269 - type: 'ref', 1270 1270 - ref: 'lex:app.rocksky.artist.defs#artistViewBasic', 1279 1279 + type: "ref", 1280 1280 + ref: "lex:app.rocksky.artist.defs#artistViewBasic", 1271 1281 }, 1272 1282 }, 1273 1283 }, ··· 1278 1288 }, 1279 1289 AppRockskyArtistGetArtistTracks: { 1280 1290 lexicon: 1, 1281 1281 - id: 'app.rocksky.artist.getArtistTracks', 1291 1291 + id: "app.rocksky.artist.getArtistTracks", 1282 1292 defs: { 1283 1293 main: { 1284 1284 - type: 'query', 1294 1294 + type: "query", 1285 1295 description: "Get artist's tracks", 1286 1296 parameters: { 1287 1287 - type: 'params', 1297 1297 + type: "params", 1288 1298 properties: { 1289 1299 uri: { 1290 1290 - type: 'string', 1291 1291 - description: 'The URI of the artist to retrieve albums from', 1292 1292 - format: 'at-uri', 1300 1300 + type: "string", 1301 1301 + description: "The URI of the artist to retrieve albums from", 1302 1302 + format: "at-uri", 1293 1303 }, 1294 1304 limit: { 1295 1295 - type: 'integer', 1296 1296 - description: 'The maximum number of tracks to return', 1305 1305 + type: "integer", 1306 1306 + description: "The maximum number of tracks to return", 1297 1307 minimum: 1, 1298 1308 }, 1299 1309 offset: { 1300 1300 - type: 'integer', 1301 1301 - description: 'The offset for pagination', 1310 1310 + type: "integer", 1311 1311 + description: "The offset for pagination", 1302 1312 minimum: 0, 1303 1313 }, 1304 1314 }, 1305 1315 }, 1306 1316 output: { 1307 1307 - encoding: 'application/json', 1317 1317 + encoding: "application/json", 1308 1318 schema: { 1309 1309 - type: 'object', 1319 1319 + type: "object", 1310 1320 properties: { 1311 1321 tracks: { 1312 1312 - type: 'array', 1322 1322 + type: "array", 1313 1323 items: { 1314 1314 - type: 'ref', 1315 1315 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 1324 1324 + type: "ref", 1325 1325 + ref: "lex:app.rocksky.song.defs#songViewBasic", 1316 1326 }, 1317 1327 }, 1318 1328 }, ··· 1323 1333 }, 1324 1334 AppRockskyChartsDefs: { 1325 1335 lexicon: 1, 1326 1326 - id: 'app.rocksky.charts.defs', 1336 1336 + id: "app.rocksky.charts.defs", 1327 1337 defs: { 1328 1338 chartsView: { 1329 1329 - type: 'object', 1339 1339 + type: "object", 1330 1340 properties: { 1331 1341 scrobbles: { 1332 1332 - type: 'array', 1342 1342 + type: "array", 1333 1343 items: { 1334 1334 - type: 'ref', 1335 1335 - ref: 'lex:app.rocksky.charts.defs#scrobbleViewBasic', 1344 1344 + type: "ref", 1345 1345 + ref: "lex:app.rocksky.charts.defs#scrobbleViewBasic", 1336 1346 }, 1337 1347 }, 1338 1348 }, 1339 1349 }, 1340 1350 scrobbleViewBasic: { 1341 1341 - type: 'object', 1351 1351 + type: "object", 1342 1352 properties: { 1343 1353 date: { 1344 1344 - type: 'string', 1345 1345 - description: 'The date of the scrobble.', 1346 1346 - format: 'datetime', 1354 1354 + type: "string", 1355 1355 + description: "The date of the scrobble.", 1356 1356 + format: "datetime", 1347 1357 }, 1348 1358 count: { 1349 1349 - type: 'integer', 1350 1350 - description: 'The number of scrobbles on this date.', 1359 1359 + type: "integer", 1360 1360 + description: "The number of scrobbles on this date.", 1351 1361 }, 1352 1362 }, 1353 1363 }, ··· 1355 1365 }, 1356 1366 AppRockskyChartsGetScrobblesChart: { 1357 1367 lexicon: 1, 1358 1358 - id: 'app.rocksky.charts.getScrobblesChart', 1368 1368 + id: "app.rocksky.charts.getScrobblesChart", 1359 1369 defs: { 1360 1370 main: { 1361 1361 - type: 'query', 1362 1362 - description: 'Get the scrobbles chart', 1371 1371 + type: "query", 1372 1372 + description: "Get the scrobbles chart", 1363 1373 parameters: { 1364 1364 - type: 'params', 1374 1374 + type: "params", 1365 1375 properties: { 1366 1376 did: { 1367 1367 - type: 'string', 1368 1368 - description: 'The DID or handle of the actor', 1369 1369 - format: 'at-identifier', 1377 1377 + type: "string", 1378 1378 + description: "The DID or handle of the actor", 1379 1379 + format: "at-identifier", 1370 1380 }, 1371 1381 artisturi: { 1372 1372 - type: 'string', 1373 1373 - description: 'The URI of the artist to filter by', 1374 1374 - format: 'at-uri', 1382 1382 + type: "string", 1383 1383 + description: "The URI of the artist to filter by", 1384 1384 + format: "at-uri", 1375 1385 }, 1376 1386 albumuri: { 1377 1377 - type: 'string', 1378 1378 - description: 'The URI of the album to filter by', 1379 1379 - format: 'at-uri', 1387 1387 + type: "string", 1388 1388 + description: "The URI of the album to filter by", 1389 1389 + format: "at-uri", 1380 1390 }, 1381 1391 songuri: { 1382 1382 - type: 'string', 1383 1383 - description: 'The URI of the track to filter by', 1384 1384 - format: 'at-uri', 1392 1392 + type: "string", 1393 1393 + description: "The URI of the track to filter by", 1394 1394 + format: "at-uri", 1385 1395 }, 1386 1396 }, 1387 1397 }, 1388 1398 output: { 1389 1389 - encoding: 'application/json', 1399 1399 + encoding: "application/json", 1390 1400 schema: { 1391 1391 - type: 'ref', 1392 1392 - ref: 'lex:app.rocksky.charts.defs#chartsView', 1401 1401 + type: "ref", 1402 1402 + ref: "lex:app.rocksky.charts.defs#chartsView", 1393 1403 }, 1394 1404 }, 1395 1405 }, ··· 1397 1407 }, 1398 1408 AppRockskyDropboxDefs: { 1399 1409 lexicon: 1, 1400 1400 - id: 'app.rocksky.dropbox.defs', 1410 1410 + id: "app.rocksky.dropbox.defs", 1401 1411 defs: { 1402 1412 fileView: { 1403 1403 - type: 'object', 1413 1413 + type: "object", 1404 1414 properties: { 1405 1415 id: { 1406 1406 - type: 'string', 1407 1407 - description: 'The unique identifier of the file.', 1416 1416 + type: "string", 1417 1417 + description: "The unique identifier of the file.", 1408 1418 }, 1409 1419 name: { 1410 1410 - type: 'string', 1411 1411 - description: 'The name of the file.', 1420 1420 + type: "string", 1421 1421 + description: "The name of the file.", 1412 1422 }, 1413 1423 pathLower: { 1414 1414 - type: 'string', 1415 1415 - description: 'The lowercased path of the file.', 1424 1424 + type: "string", 1425 1425 + description: "The lowercased path of the file.", 1416 1426 }, 1417 1427 pathDisplay: { 1418 1418 - type: 'string', 1419 1419 - description: 'The display path of the file.', 1428 1428 + type: "string", 1429 1429 + description: "The display path of the file.", 1420 1430 }, 1421 1431 clientModified: { 1422 1422 - type: 'string', 1432 1432 + type: "string", 1423 1433 description: 1424 1424 - 'The last modified date and time of the file on the client.', 1425 1425 - format: 'datetime', 1434 1434 + "The last modified date and time of the file on the client.", 1435 1435 + format: "datetime", 1426 1436 }, 1427 1437 serverModified: { 1428 1428 - type: 'string', 1438 1438 + type: "string", 1429 1439 description: 1430 1430 - 'The last modified date and time of the file on the server.', 1431 1431 - format: 'datetime', 1440 1440 + "The last modified date and time of the file on the server.", 1441 1441 + format: "datetime", 1432 1442 }, 1433 1443 }, 1434 1444 }, 1435 1445 fileListView: { 1436 1436 - type: 'object', 1446 1446 + type: "object", 1437 1447 properties: { 1438 1448 files: { 1439 1439 - type: 'array', 1440 1440 - description: 'A list of files in the Dropbox.', 1449 1449 + type: "array", 1450 1450 + description: "A list of files in the Dropbox.", 1441 1451 items: { 1442 1442 - type: 'ref', 1443 1443 - ref: 'lex:app.rocksky.dropbox.defs#fileView', 1452 1452 + type: "ref", 1453 1453 + ref: "lex:app.rocksky.dropbox.defs#fileView", 1444 1454 }, 1445 1455 }, 1446 1456 }, 1447 1457 }, 1448 1458 temporaryLinkView: { 1449 1449 - type: 'object', 1459 1459 + type: "object", 1450 1460 properties: { 1451 1461 link: { 1452 1452 - type: 'string', 1453 1453 - description: 'The temporary link to access the file.', 1454 1454 - format: 'uri', 1462 1462 + type: "string", 1463 1463 + description: "The temporary link to access the file.", 1464 1464 + format: "uri", 1455 1465 }, 1456 1466 }, 1457 1467 }, ··· 1459 1469 }, 1460 1470 AppRockskyDropboxDownloadFile: { 1461 1471 lexicon: 1, 1462 1462 - id: 'app.rocksky.dropbox.downloadFile', 1472 1472 + id: "app.rocksky.dropbox.downloadFile", 1463 1473 defs: { 1464 1474 main: { 1465 1465 - type: 'query', 1466 1466 - description: 'Download a file from Dropbox by its unique identifier', 1475 1475 + type: "query", 1476 1476 + description: "Download a file from Dropbox by its unique identifier", 1467 1477 parameters: { 1468 1468 - type: 'params', 1469 1469 - required: ['fileId'], 1478 1478 + type: "params", 1479 1479 + required: ["fileId"], 1470 1480 properties: { 1471 1481 fileId: { 1472 1472 - type: 'string', 1473 1473 - description: 'The unique identifier of the file to download', 1482 1482 + type: "string", 1483 1483 + description: "The unique identifier of the file to download", 1474 1484 }, 1475 1485 }, 1476 1486 }, 1477 1487 output: { 1478 1478 - encoding: 'application/octet-stream', 1488 1488 + encoding: "application/octet-stream", 1479 1489 }, 1480 1490 }, 1481 1491 }, 1482 1492 }, 1483 1493 AppRockskyDropboxGetFiles: { 1484 1494 lexicon: 1, 1485 1485 - id: 'app.rocksky.dropbox.getFiles', 1495 1495 + id: "app.rocksky.dropbox.getFiles", 1486 1496 defs: { 1487 1497 main: { 1488 1488 - type: 'query', 1489 1489 - description: 'Retrieve a list of files from Dropbox', 1498 1498 + type: "query", 1499 1499 + description: "Retrieve a list of files from Dropbox", 1490 1500 parameters: { 1491 1491 - type: 'params', 1501 1501 + type: "params", 1492 1502 properties: { 1493 1503 at: { 1494 1494 - type: 'string', 1495 1495 - description: 'Path to the Dropbox folder or root directory', 1504 1504 + type: "string", 1505 1505 + description: "Path to the Dropbox folder or root directory", 1496 1506 }, 1497 1507 }, 1498 1508 }, 1499 1509 output: { 1500 1500 - encoding: 'application/json', 1510 1510 + encoding: "application/json", 1501 1511 schema: { 1502 1502 - type: 'ref', 1503 1503 - ref: 'lex:app.rocksky.dropbox.defs#fileListView', 1512 1512 + type: "ref", 1513 1513 + ref: "lex:app.rocksky.dropbox.defs#fileListView", 1504 1514 }, 1505 1515 }, 1506 1516 }, ··· 1508 1518 }, 1509 1519 AppRockskyDropboxGetMetadata: { 1510 1520 lexicon: 1, 1511 1511 - id: 'app.rocksky.dropbox.getMetadata', 1521 1521 + id: "app.rocksky.dropbox.getMetadata", 1512 1522 defs: { 1513 1523 main: { 1514 1514 - type: 'query', 1515 1515 - description: 'Retrieve metadata of a file or folder in Dropbox', 1524 1524 + type: "query", 1525 1525 + description: "Retrieve metadata of a file or folder in Dropbox", 1516 1526 parameters: { 1517 1517 - type: 'params', 1518 1518 - required: ['path'], 1527 1527 + type: "params", 1528 1528 + required: ["path"], 1519 1529 properties: { 1520 1530 path: { 1521 1521 - type: 'string', 1522 1522 - description: 'Path to the file or folder in Dropbox', 1531 1531 + type: "string", 1532 1532 + description: "Path to the file or folder in Dropbox", 1523 1533 }, 1524 1534 }, 1525 1535 }, 1526 1536 output: { 1527 1527 - encoding: 'application/json', 1537 1537 + encoding: "application/json", 1528 1538 schema: { 1529 1529 - type: 'ref', 1530 1530 - ref: 'lex:app.rocksky.dropbox.defs#fileView', 1539 1539 + type: "ref", 1540 1540 + ref: "lex:app.rocksky.dropbox.defs#fileView", 1531 1541 }, 1532 1542 }, 1533 1543 }, ··· 1535 1545 }, 1536 1546 AppRockskyDropboxGetTemporaryLink: { 1537 1547 lexicon: 1, 1538 1538 - id: 'app.rocksky.dropbox.getTemporaryLink', 1548 1548 + id: "app.rocksky.dropbox.getTemporaryLink", 1539 1549 defs: { 1540 1550 main: { 1541 1541 - type: 'query', 1542 1542 - description: 'Retrieve a temporary link to access a file in Dropbox', 1551 1551 + type: "query", 1552 1552 + description: "Retrieve a temporary link to access a file in Dropbox", 1543 1553 parameters: { 1544 1544 - type: 'params', 1545 1545 - required: ['path'], 1554 1554 + type: "params", 1555 1555 + required: ["path"], 1546 1556 properties: { 1547 1557 path: { 1548 1548 - type: 'string', 1549 1549 - description: 'Path to the file in Dropbox', 1558 1558 + type: "string", 1559 1559 + description: "Path to the file in Dropbox", 1550 1560 }, 1551 1561 }, 1552 1562 }, 1553 1563 output: { 1554 1554 - encoding: 'application/json', 1564 1564 + encoding: "application/json", 1555 1565 schema: { 1556 1556 - type: 'ref', 1557 1557 - ref: 'lex:app.rocksky.dropbox.defs#temporaryLinkView', 1566 1566 + type: "ref", 1567 1567 + ref: "lex:app.rocksky.dropbox.defs#temporaryLinkView", 1558 1568 }, 1559 1569 }, 1560 1570 }, ··· 1562 1572 }, 1563 1573 AppRockskyFeedDefs: { 1564 1574 lexicon: 1, 1565 1565 - id: 'app.rocksky.feed.defs', 1575 1575 + id: "app.rocksky.feed.defs", 1566 1576 defs: { 1567 1577 searchResultsView: { 1568 1568 - type: 'object', 1578 1578 + type: "object", 1569 1579 properties: { 1570 1580 hits: { 1571 1571 - type: 'array', 1581 1581 + type: "array", 1572 1582 items: { 1573 1573 - type: 'union', 1583 1583 + type: "union", 1574 1584 refs: [ 1575 1575 - 'lex:app.rocksky.song.defs#songViewBasic', 1576 1576 - 'lex:app.rocksky.album.defs#albumViewBasic', 1577 1577 - 'lex:app.rocksky.artist.defs#artistViewBasic', 1578 1578 - 'lex:app.rocksky.playlist.defs#playlistViewBasic', 1579 1579 - 'lex:app.rocksky.actor.defs#profileViewBasic', 1585 1585 + "lex:app.rocksky.song.defs#songViewBasic", 1586 1586 + "lex:app.rocksky.album.defs#albumViewBasic", 1587 1587 + "lex:app.rocksky.artist.defs#artistViewBasic", 1588 1588 + "lex:app.rocksky.playlist.defs#playlistViewBasic", 1589 1589 + "lex:app.rocksky.actor.defs#profileViewBasic", 1580 1590 ], 1581 1591 }, 1582 1592 }, 1583 1593 processingTimeMs: { 1584 1584 - type: 'integer', 1594 1594 + type: "integer", 1585 1595 }, 1586 1596 limit: { 1587 1587 - type: 'integer', 1597 1597 + type: "integer", 1588 1598 }, 1589 1599 offset: { 1590 1590 - type: 'integer', 1600 1600 + type: "integer", 1591 1601 }, 1592 1602 estimatedTotalHits: { 1593 1593 - type: 'integer', 1603 1603 + type: "integer", 1594 1604 }, 1595 1605 }, 1596 1606 }, 1597 1607 nowPlayingView: { 1598 1598 - type: 'object', 1608 1608 + type: "object", 1599 1609 properties: { 1600 1610 album: { 1601 1601 - type: 'string', 1611 1611 + type: "string", 1602 1612 }, 1603 1613 albumArt: { 1604 1604 - type: 'string', 1605 1605 - format: 'uri', 1614 1614 + type: "string", 1615 1615 + format: "uri", 1606 1616 }, 1607 1617 albumArtist: { 1608 1608 - type: 'string', 1618 1618 + type: "string", 1609 1619 }, 1610 1620 albumUri: { 1611 1611 - type: 'string', 1612 1612 - format: 'at-uri', 1621 1621 + type: "string", 1622 1622 + format: "at-uri", 1613 1623 }, 1614 1624 artist: { 1615 1615 - type: 'string', 1625 1625 + type: "string", 1616 1626 }, 1617 1627 artistUri: { 1618 1618 - type: 'string', 1619 1619 - format: 'at-uri', 1628 1628 + type: "string", 1629 1629 + format: "at-uri", 1620 1630 }, 1621 1631 avatar: { 1622 1622 - type: 'string', 1623 1623 - format: 'uri', 1632 1632 + type: "string", 1633 1633 + format: "uri", 1624 1634 }, 1625 1635 createdAt: { 1626 1626 - type: 'string', 1636 1636 + type: "string", 1627 1637 }, 1628 1638 did: { 1629 1629 - type: 'string', 1630 1630 - format: 'at-identifier', 1639 1639 + type: "string", 1640 1640 + format: "at-identifier", 1631 1641 }, 1632 1642 handle: { 1633 1633 - type: 'string', 1643 1643 + type: "string", 1634 1644 }, 1635 1645 id: { 1636 1636 - type: 'string', 1646 1646 + type: "string", 1637 1647 }, 1638 1648 title: { 1639 1639 - type: 'string', 1649 1649 + type: "string", 1640 1650 }, 1641 1651 trackId: { 1642 1642 - type: 'string', 1652 1652 + type: "string", 1643 1653 }, 1644 1654 trackUri: { 1645 1645 - type: 'string', 1646 1646 - format: 'at-uri', 1655 1655 + type: "string", 1656 1656 + format: "at-uri", 1647 1657 }, 1648 1658 uri: { 1649 1649 - type: 'string', 1650 1650 - format: 'at-uri', 1659 1659 + type: "string", 1660 1660 + format: "at-uri", 1651 1661 }, 1652 1662 }, 1653 1663 }, 1654 1664 nowPlayingsView: { 1655 1655 - type: 'object', 1665 1665 + type: "object", 1656 1666 properties: { 1657 1667 nowPlayings: { 1658 1658 - type: 'array', 1668 1668 + type: "array", 1659 1669 items: { 1660 1660 - type: 'ref', 1661 1661 - ref: 'lex:app.rocksky.feed.defs#nowPlayingView', 1670 1670 + type: "ref", 1671 1671 + ref: "lex:app.rocksky.feed.defs#nowPlayingView", 1662 1672 }, 1663 1673 }, 1664 1674 }, ··· 1667 1677 }, 1668 1678 AppRockskyFeedGetNowPlayings: { 1669 1679 lexicon: 1, 1670 1670 - id: 'app.rocksky.feed.getNowPlayings', 1680 1680 + id: "app.rocksky.feed.getNowPlayings", 1671 1681 defs: { 1672 1682 main: { 1673 1673 - type: 'query', 1674 1674 - description: 'Get all currently playing tracks by users', 1683 1683 + type: "query", 1684 1684 + description: "Get all currently playing tracks by users", 1675 1685 parameters: { 1676 1676 - type: 'params', 1686 1686 + type: "params", 1677 1687 properties: { 1678 1688 size: { 1679 1679 - type: 'integer', 1689 1689 + type: "integer", 1680 1690 description: 1681 1681 - 'The maximum number of now playing tracks to return.', 1691 1691 + "The maximum number of now playing tracks to return.", 1682 1692 minimum: 1, 1683 1693 }, 1684 1694 }, 1685 1695 }, 1686 1696 output: { 1687 1687 - encoding: 'application/json', 1697 1697 + encoding: "application/json", 1688 1698 schema: { 1689 1689 - type: 'ref', 1690 1690 - ref: 'lex:app.rocksky.feed.defs#nowPlayingsView', 1699 1699 + type: "ref", 1700 1700 + ref: "lex:app.rocksky.feed.defs#nowPlayingsView", 1691 1701 }, 1692 1702 }, 1693 1703 }, ··· 1695 1705 }, 1696 1706 AppRockskyFeedSearch: { 1697 1707 lexicon: 1, 1698 1698 - id: 'app.rocksky.feed.search', 1708 1708 + id: "app.rocksky.feed.search", 1699 1709 defs: { 1700 1710 main: { 1701 1701 - type: 'query', 1702 1702 - description: 'Search for content in the feed', 1711 1711 + type: "query", 1712 1712 + description: "Search for content in the feed", 1703 1713 parameters: { 1704 1704 - type: 'params', 1705 1705 - required: ['query'], 1714 1714 + type: "params", 1715 1715 + required: ["query"], 1706 1716 properties: { 1707 1717 query: { 1708 1708 - type: 'string', 1709 1709 - description: 'The search query string', 1718 1718 + type: "string", 1719 1719 + description: "The search query string", 1710 1720 }, 1711 1721 }, 1712 1722 }, 1713 1723 output: { 1714 1714 - encoding: 'application/json', 1724 1724 + encoding: "application/json", 1715 1725 schema: { 1716 1716 - type: 'ref', 1717 1717 - ref: 'lex:app.rocksky.feed.defs#searchResultsView', 1726 1726 + type: "ref", 1727 1727 + ref: "lex:app.rocksky.feed.defs#searchResultsView", 1718 1728 }, 1719 1729 }, 1720 1730 }, ··· 1722 1732 }, 1723 1733 AppRockskyGoogledriveDefs: { 1724 1734 lexicon: 1, 1725 1725 - id: 'app.rocksky.googledrive.defs', 1735 1735 + id: "app.rocksky.googledrive.defs", 1726 1736 defs: { 1727 1737 fileView: { 1728 1728 - type: 'object', 1738 1738 + type: "object", 1729 1739 properties: { 1730 1740 id: { 1731 1731 - type: 'string', 1732 1732 - description: 'The unique identifier of the file.', 1741 1741 + type: "string", 1742 1742 + description: "The unique identifier of the file.", 1733 1743 }, 1734 1744 }, 1735 1745 }, 1736 1746 fileListView: { 1737 1737 - type: 'object', 1747 1747 + type: "object", 1738 1748 properties: { 1739 1749 files: { 1740 1740 - type: 'array', 1750 1750 + type: "array", 1741 1751 items: { 1742 1742 - type: 'ref', 1743 1743 - ref: 'lex:app.rocksky.googledrive.defs#fileView', 1752 1752 + type: "ref", 1753 1753 + ref: "lex:app.rocksky.googledrive.defs#fileView", 1744 1754 }, 1745 1755 }, 1746 1756 }, ··· 1749 1759 }, 1750 1760 AppRockskyGoogledriveDownloadFile: { 1751 1761 lexicon: 1, 1752 1752 - id: 'app.rocksky.googledrive.downloadFile', 1762 1762 + id: "app.rocksky.googledrive.downloadFile", 1753 1763 defs: { 1754 1764 main: { 1755 1755 - type: 'query', 1765 1765 + type: "query", 1756 1766 description: 1757 1757 - 'Download a file from Google Drive by its unique identifier', 1767 1767 + "Download a file from Google Drive by its unique identifier", 1758 1768 parameters: { 1759 1759 - type: 'params', 1760 1760 - required: ['fileId'], 1769 1769 + type: "params", 1770 1770 + required: ["fileId"], 1761 1771 properties: { 1762 1772 fileId: { 1763 1763 - type: 'string', 1764 1764 - description: 'The unique identifier of the file to download', 1773 1773 + type: "string", 1774 1774 + description: "The unique identifier of the file to download", 1765 1775 }, 1766 1776 }, 1767 1777 }, 1768 1778 output: { 1769 1769 - encoding: 'application/octet-stream', 1779 1779 + encoding: "application/octet-stream", 1770 1780 }, 1771 1781 }, 1772 1782 }, 1773 1783 }, 1774 1784 AppRockskyGoogledriveGetFile: { 1775 1785 lexicon: 1, 1776 1776 - id: 'app.rocksky.googledrive.getFile', 1786 1786 + id: "app.rocksky.googledrive.getFile", 1777 1787 defs: { 1778 1788 main: { 1779 1779 - type: 'query', 1780 1780 - description: 'Get a file from Google Drive by its unique identifier', 1789 1789 + type: "query", 1790 1790 + description: "Get a file from Google Drive by its unique identifier", 1781 1791 parameters: { 1782 1782 - type: 'params', 1783 1783 - required: ['fileId'], 1792 1792 + type: "params", 1793 1793 + required: ["fileId"], 1784 1794 properties: { 1785 1795 fileId: { 1786 1786 - type: 'string', 1787 1787 - description: 'The unique identifier of the file to retrieve', 1796 1796 + type: "string", 1797 1797 + description: "The unique identifier of the file to retrieve", 1788 1798 }, 1789 1799 }, 1790 1800 }, 1791 1801 output: { 1792 1792 - encoding: 'application/json', 1802 1802 + encoding: "application/json", 1793 1803 schema: { 1794 1794 - type: 'ref', 1795 1795 - ref: 'lex:app.rocksky.googledrive.defs#fileView', 1804 1804 + type: "ref", 1805 1805 + ref: "lex:app.rocksky.googledrive.defs#fileView", 1796 1806 }, 1797 1807 }, 1798 1808 }, ··· 1800 1810 }, 1801 1811 AppRockskyGoogledriveGetFiles: { 1802 1812 lexicon: 1, 1803 1803 - id: 'app.rocksky.googledrive.getFiles', 1813 1813 + id: "app.rocksky.googledrive.getFiles", 1804 1814 defs: { 1805 1815 main: { 1806 1806 - type: 'query', 1807 1807 - description: 'Get a list of files from Google Drive', 1816 1816 + type: "query", 1817 1817 + description: "Get a list of files from Google Drive", 1808 1818 parameters: { 1809 1809 - type: 'params', 1819 1819 + type: "params", 1810 1820 properties: { 1811 1821 at: { 1812 1812 - type: 'string', 1813 1813 - description: 'Path to the Google Drive folder or root directory', 1822 1822 + type: "string", 1823 1823 + description: "Path to the Google Drive folder or root directory", 1814 1824 }, 1815 1825 }, 1816 1826 }, 1817 1827 output: { 1818 1818 - encoding: 'application/json', 1828 1828 + encoding: "application/json", 1819 1829 schema: { 1820 1820 - type: 'ref', 1821 1821 - ref: 'lex:app.rocksky.googledrive.defs#fileListView', 1830 1830 + type: "ref", 1831 1831 + ref: "lex:app.rocksky.googledrive.defs#fileListView", 1822 1832 }, 1823 1833 }, 1824 1834 }, ··· 1826 1836 }, 1827 1837 AppRockskyLikeDislikeShout: { 1828 1838 lexicon: 1, 1829 1829 - id: 'app.rocksky.like.dislikeShout', 1839 1839 + id: "app.rocksky.like.dislikeShout", 1830 1840 defs: { 1831 1841 main: { 1832 1832 - type: 'procedure', 1833 1833 - description: 'Dislike a shout', 1842 1842 + type: "procedure", 1843 1843 + description: "Dislike a shout", 1834 1844 input: { 1835 1835 - encoding: 'application/json', 1845 1845 + encoding: "application/json", 1836 1846 schema: { 1837 1837 - type: 'object', 1847 1847 + type: "object", 1838 1848 properties: { 1839 1849 uri: { 1840 1840 - type: 'string', 1841 1841 - description: 'The unique identifier of the shout to dislike', 1842 1842 - format: 'at-uri', 1850 1850 + type: "string", 1851 1851 + description: "The unique identifier of the shout to dislike", 1852 1852 + format: "at-uri", 1843 1853 }, 1844 1854 }, 1845 1855 }, 1846 1856 }, 1847 1857 output: { 1848 1848 - encoding: 'application/json', 1858 1858 + encoding: "application/json", 1849 1859 schema: { 1850 1850 - type: 'ref', 1851 1851 - ref: 'lex:app.rocksky.shout.defs#shoutView', 1860 1860 + type: "ref", 1861 1861 + ref: "lex:app.rocksky.shout.defs#shoutView", 1852 1862 }, 1853 1863 }, 1854 1864 }, ··· 1856 1866 }, 1857 1867 AppRockskyLikeDislikeSong: { 1858 1868 lexicon: 1, 1859 1859 - id: 'app.rocksky.like.dislikeSong', 1869 1869 + id: "app.rocksky.like.dislikeSong", 1860 1870 defs: { 1861 1871 main: { 1862 1862 - type: 'procedure', 1863 1863 - description: 'Dislike a song', 1872 1872 + type: "procedure", 1873 1873 + description: "Dislike a song", 1864 1874 input: { 1865 1865 - encoding: 'application/json', 1875 1875 + encoding: "application/json", 1866 1876 schema: { 1867 1867 - type: 'object', 1877 1877 + type: "object", 1868 1878 properties: { 1869 1879 uri: { 1870 1870 - type: 'string', 1871 1871 - description: 'The unique identifier of the song to dislike', 1872 1872 - format: 'at-uri', 1880 1880 + type: "string", 1881 1881 + description: "The unique identifier of the song to dislike", 1882 1882 + format: "at-uri", 1873 1883 }, 1874 1884 }, 1875 1885 }, 1876 1886 }, 1877 1887 output: { 1878 1878 - encoding: 'application/json', 1888 1888 + encoding: "application/json", 1879 1889 schema: { 1880 1880 - type: 'ref', 1881 1881 - ref: 'lex:app.rocksky.song.defs#songViewDetailed', 1890 1890 + type: "ref", 1891 1891 + ref: "lex:app.rocksky.song.defs#songViewDetailed", 1882 1892 }, 1883 1893 }, 1884 1894 }, ··· 1886 1896 }, 1887 1897 AppRockskyLike: { 1888 1898 lexicon: 1, 1889 1889 - id: 'app.rocksky.like', 1899 1899 + id: "app.rocksky.like", 1890 1900 defs: { 1891 1901 main: { 1892 1892 - type: 'record', 1893 1893 - description: 'A declaration of a like.', 1894 1894 - key: 'tid', 1902 1902 + type: "record", 1903 1903 + description: "A declaration of a like.", 1904 1904 + key: "tid", 1895 1905 record: { 1896 1896 - type: 'object', 1897 1897 - required: ['createdAt', 'subject'], 1906 1906 + type: "object", 1907 1907 + required: ["createdAt", "subject"], 1898 1908 properties: { 1899 1909 createdAt: { 1900 1900 - type: 'string', 1901 1901 - description: 'The date when the like was created.', 1902 1902 - format: 'datetime', 1910 1910 + type: "string", 1911 1911 + description: "The date when the like was created.", 1912 1912 + format: "datetime", 1903 1913 }, 1904 1914 subject: { 1905 1905 - type: 'ref', 1906 1906 - ref: 'lex:com.atproto.repo.strongRef', 1915 1915 + type: "ref", 1916 1916 + ref: "lex:com.atproto.repo.strongRef", 1907 1917 }, 1908 1918 }, 1909 1919 }, ··· 1912 1922 }, 1913 1923 AppRockskyLikeLikeShout: { 1914 1924 lexicon: 1, 1915 1915 - id: 'app.rocksky.like.likeShout', 1925 1925 + id: "app.rocksky.like.likeShout", 1916 1926 defs: { 1917 1927 main: { 1918 1918 - type: 'procedure', 1919 1919 - description: 'Like a shout', 1928 1928 + type: "procedure", 1929 1929 + description: "Like a shout", 1920 1930 input: { 1921 1921 - encoding: 'application/json', 1931 1931 + encoding: "application/json", 1922 1932 schema: { 1923 1923 - type: 'object', 1933 1933 + type: "object", 1924 1934 properties: { 1925 1935 uri: { 1926 1926 - type: 'string', 1927 1927 - description: 'The unique identifier of the shout to like', 1928 1928 - format: 'at-uri', 1936 1936 + type: "string", 1937 1937 + description: "The unique identifier of the shout to like", 1938 1938 + format: "at-uri", 1929 1939 }, 1930 1940 }, 1931 1941 }, 1932 1942 }, 1933 1943 output: { 1934 1934 - encoding: 'application/json', 1944 1944 + encoding: "application/json", 1935 1945 schema: { 1936 1936 - type: 'ref', 1937 1937 - ref: 'lex:app.rocksky.shout.defs#shoutView', 1946 1946 + type: "ref", 1947 1947 + ref: "lex:app.rocksky.shout.defs#shoutView", 1938 1948 }, 1939 1949 }, 1940 1950 }, ··· 1942 1952 }, 1943 1953 AppRockskyLikeLikeSong: { 1944 1954 lexicon: 1, 1945 1945 - id: 'app.rocksky.like.likeSong', 1955 1955 + id: "app.rocksky.like.likeSong", 1946 1956 defs: { 1947 1957 main: { 1948 1948 - type: 'procedure', 1949 1949 - description: 'Like a song', 1958 1958 + type: "procedure", 1959 1959 + description: "Like a song", 1950 1960 input: { 1951 1951 - encoding: 'application/json', 1961 1961 + encoding: "application/json", 1952 1962 schema: { 1953 1953 - type: 'object', 1963 1963 + type: "object", 1954 1964 properties: { 1955 1965 uri: { 1956 1956 - type: 'string', 1957 1957 - description: 'The unique identifier of the song to like', 1958 1958 - format: 'at-uri', 1966 1966 + type: "string", 1967 1967 + description: "The unique identifier of the song to like", 1968 1968 + format: "at-uri", 1959 1969 }, 1960 1970 }, 1961 1971 }, 1962 1972 }, 1963 1973 output: { 1964 1964 - encoding: 'application/json', 1974 1974 + encoding: "application/json", 1965 1975 schema: { 1966 1966 - type: 'ref', 1967 1967 - ref: 'lex:app.rocksky.song.defs#songViewDetailed', 1976 1976 + type: "ref", 1977 1977 + ref: "lex:app.rocksky.song.defs#songViewDetailed", 1968 1978 }, 1969 1979 }, 1970 1980 }, ··· 1972 1982 }, 1973 1983 AppRockskyPlayerAddDirectoryToQueue: { 1974 1984 lexicon: 1, 1975 1975 - id: 'app.rocksky.player.addDirectoryToQueue', 1985 1985 + id: "app.rocksky.player.addDirectoryToQueue", 1976 1986 defs: { 1977 1987 main: { 1978 1978 - type: 'procedure', 1988 1988 + type: "procedure", 1979 1989 description: "Add directory to the player's queue", 1980 1990 parameters: { 1981 1981 - type: 'params', 1982 1982 - required: ['directory'], 1991 1991 + type: "params", 1992 1992 + required: ["directory"], 1983 1993 properties: { 1984 1994 playerId: { 1985 1985 - type: 'string', 1995 1995 + type: "string", 1986 1996 }, 1987 1997 directory: { 1988 1988 - type: 'string', 1989 1989 - description: 'The directory to add to the queue', 1998 1998 + type: "string", 1999 1999 + description: "The directory to add to the queue", 1990 2000 }, 1991 2001 position: { 1992 1992 - type: 'integer', 2002 2002 + type: "integer", 1993 2003 description: 1994 1994 - 'Position in the queue to insert the directory at, defaults to the end if not specified', 2004 2004 + "Position in the queue to insert the directory at, defaults to the end if not specified", 1995 2005 }, 1996 2006 shuffle: { 1997 1997 - type: 'boolean', 2007 2007 + type: "boolean", 1998 2008 description: 1999 1999 - 'Whether to shuffle the added directory in the queue', 2009 2009 + "Whether to shuffle the added directory in the queue", 2000 2010 }, 2001 2011 }, 2002 2012 }, ··· 2005 2015 }, 2006 2016 AppRockskyPlayerAddItemsToQueue: { 2007 2017 lexicon: 1, 2008 2008 - id: 'app.rocksky.player.addItemsToQueue', 2018 2018 + id: "app.rocksky.player.addItemsToQueue", 2009 2019 defs: { 2010 2020 main: { 2011 2011 - type: 'procedure', 2021 2021 + type: "procedure", 2012 2022 description: "Add items to the player's queue", 2013 2023 parameters: { 2014 2014 - type: 'params', 2015 2015 - required: ['items'], 2024 2024 + type: "params", 2025 2025 + required: ["items"], 2016 2026 properties: { 2017 2027 playerId: { 2018 2018 - type: 'string', 2028 2028 + type: "string", 2019 2029 }, 2020 2030 items: { 2021 2021 - type: 'array', 2031 2031 + type: "array", 2022 2032 items: { 2023 2023 - type: 'string', 2024 2024 - description: 'List of file identifiers to add to the queue', 2033 2033 + type: "string", 2034 2034 + description: "List of file identifiers to add to the queue", 2025 2035 }, 2026 2036 }, 2027 2037 position: { 2028 2028 - type: 'integer', 2038 2038 + type: "integer", 2029 2039 description: 2030 2030 - 'Position in the queue to insert the items at, defaults to the end if not specified', 2040 2040 + "Position in the queue to insert the items at, defaults to the end if not specified", 2031 2041 }, 2032 2042 shuffle: { 2033 2033 - type: 'boolean', 2034 2034 - description: 'Whether to shuffle the added items in the queue', 2043 2043 + type: "boolean", 2044 2044 + description: "Whether to shuffle the added items in the queue", 2035 2045 }, 2036 2046 }, 2037 2047 }, ··· 2040 2050 }, 2041 2051 AppRockskyPlayerDefs: { 2042 2052 lexicon: 1, 2043 2043 - id: 'app.rocksky.player.defs', 2053 2053 + id: "app.rocksky.player.defs", 2044 2054 defs: { 2045 2055 currentlyPlayingViewDetailed: { 2046 2046 - type: 'object', 2056 2056 + type: "object", 2047 2057 properties: { 2048 2058 title: { 2049 2049 - type: 'string', 2050 2050 - description: 'The title of the currently playing track', 2059 2059 + type: "string", 2060 2060 + description: "The title of the currently playing track", 2051 2061 }, 2052 2062 }, 2053 2063 }, 2054 2064 playbackQueueViewDetailed: { 2055 2055 - type: 'object', 2065 2065 + type: "object", 2056 2066 properties: { 2057 2067 tracks: { 2058 2058 - type: 'array', 2068 2068 + type: "array", 2059 2069 items: { 2060 2060 - type: 'ref', 2061 2061 - ref: 'lex:app.rocksky.song.defs.songViewBasic', 2070 2070 + type: "ref", 2071 2071 + ref: "lex:app.rocksky.song.defs.songViewBasic", 2062 2072 }, 2063 2073 }, 2064 2074 }, ··· 2067 2077 }, 2068 2078 AppRockskyPlayerGetCurrentlyPlaying: { 2069 2079 lexicon: 1, 2070 2070 - id: 'app.rocksky.player.getCurrentlyPlaying', 2080 2080 + id: "app.rocksky.player.getCurrentlyPlaying", 2071 2081 defs: { 2072 2082 main: { 2073 2073 - type: 'query', 2074 2074 - description: 'Get the currently playing track', 2083 2083 + type: "query", 2084 2084 + description: "Get the currently playing track", 2075 2085 parameters: { 2076 2076 - type: 'params', 2086 2086 + type: "params", 2077 2087 properties: { 2078 2088 playerId: { 2079 2079 - type: 'string', 2089 2089 + type: "string", 2080 2090 }, 2081 2091 actor: { 2082 2082 - type: 'string', 2092 2092 + type: "string", 2083 2093 description: 2084 2084 - 'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.', 2085 2085 - format: 'at-identifier', 2094 2094 + "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.", 2095 2095 + format: "at-identifier", 2086 2096 }, 2087 2097 }, 2088 2098 }, 2089 2099 output: { 2090 2090 - encoding: 'application/json', 2100 2100 + encoding: "application/json", 2091 2101 schema: { 2092 2092 - type: 'ref', 2093 2093 - ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed', 2102 2102 + type: "ref", 2103 2103 + ref: "lex:app.rocksky.player.defs#currentlyPlayingViewDetailed", 2094 2104 }, 2095 2105 }, 2096 2106 }, ··· 2098 2108 }, 2099 2109 AppRockskyPlayerGetPlaybackQueue: { 2100 2110 lexicon: 1, 2101 2101 - id: 'app.rocksky.player.getPlaybackQueue', 2111 2111 + id: "app.rocksky.player.getPlaybackQueue", 2102 2112 defs: { 2103 2113 main: { 2104 2104 - type: 'query', 2105 2105 - description: 'Retrieve the current playback queue', 2114 2114 + type: "query", 2115 2115 + description: "Retrieve the current playback queue", 2106 2116 parameters: { 2107 2107 - type: 'params', 2117 2117 + type: "params", 2108 2118 properties: { 2109 2119 playerId: { 2110 2110 - type: 'string', 2120 2120 + type: "string", 2111 2121 }, 2112 2122 }, 2113 2123 }, 2114 2124 output: { 2115 2115 - encoding: 'application/json', 2125 2125 + encoding: "application/json", 2116 2126 schema: { 2117 2117 - type: 'ref', 2118 2118 - ref: 'lex:app.rocksky.player.defs#playbackQueueViewDetailed', 2127 2127 + type: "ref", 2128 2128 + ref: "lex:app.rocksky.player.defs#playbackQueueViewDetailed", 2119 2129 }, 2120 2130 }, 2121 2131 }, ··· 2123 2133 }, 2124 2134 AppRockskyPlayerNext: { 2125 2135 lexicon: 1, 2126 2126 - id: 'app.rocksky.player.next', 2136 2136 + id: "app.rocksky.player.next", 2127 2137 defs: { 2128 2138 main: { 2129 2129 - type: 'procedure', 2130 2130 - description: 'Play the next track in the queue', 2139 2139 + type: "procedure", 2140 2140 + description: "Play the next track in the queue", 2131 2141 parameters: { 2132 2132 - type: 'params', 2142 2142 + type: "params", 2133 2143 properties: { 2134 2144 playerId: { 2135 2135 - type: 'string', 2145 2145 + type: "string", 2136 2146 }, 2137 2147 }, 2138 2148 }, ··· 2141 2151 }, 2142 2152 AppRockskyPlayerPause: { 2143 2153 lexicon: 1, 2144 2144 - id: 'app.rocksky.player.pause', 2154 2154 + id: "app.rocksky.player.pause", 2145 2155 defs: { 2146 2156 main: { 2147 2147 - type: 'procedure', 2148 2148 - description: 'Pause the currently playing track', 2157 2157 + type: "procedure", 2158 2158 + description: "Pause the currently playing track", 2149 2159 parameters: { 2150 2150 - type: 'params', 2160 2160 + type: "params", 2151 2161 properties: { 2152 2162 playerId: { 2153 2153 - type: 'string', 2163 2163 + type: "string", 2154 2164 }, 2155 2165 }, 2156 2166 }, ··· 2159 2169 }, 2160 2170 AppRockskyPlayerPlayDirectory: { 2161 2171 lexicon: 1, 2162 2162 - id: 'app.rocksky.player.playDirectory', 2172 2172 + id: "app.rocksky.player.playDirectory", 2163 2173 defs: { 2164 2174 main: { 2165 2165 - type: 'procedure', 2166 2166 - description: 'Play all tracks in a directory', 2175 2175 + type: "procedure", 2176 2176 + description: "Play all tracks in a directory", 2167 2177 parameters: { 2168 2168 - type: 'params', 2169 2169 - required: ['directoryId'], 2178 2178 + type: "params", 2179 2179 + required: ["directoryId"], 2170 2180 properties: { 2171 2181 playerId: { 2172 2172 - type: 'string', 2182 2182 + type: "string", 2173 2183 }, 2174 2184 directoryId: { 2175 2175 - type: 'string', 2185 2185 + type: "string", 2176 2186 }, 2177 2187 shuffle: { 2178 2178 - type: 'boolean', 2188 2188 + type: "boolean", 2179 2189 }, 2180 2190 recurse: { 2181 2181 - type: 'boolean', 2191 2191 + type: "boolean", 2182 2192 }, 2183 2193 position: { 2184 2184 - type: 'integer', 2194 2194 + type: "integer", 2185 2195 }, 2186 2196 }, 2187 2197 }, ··· 2190 2200 }, 2191 2201 AppRockskyPlayerPlayFile: { 2192 2202 lexicon: 1, 2193 2193 - id: 'app.rocksky.player.playFile', 2203 2203 + id: "app.rocksky.player.playFile", 2194 2204 defs: { 2195 2205 main: { 2196 2196 - type: 'procedure', 2197 2197 - description: 'Play a specific audio file', 2206 2206 + type: "procedure", 2207 2207 + description: "Play a specific audio file", 2198 2208 parameters: { 2199 2199 - type: 'params', 2200 2200 - required: ['fileId'], 2209 2209 + type: "params", 2210 2210 + required: ["fileId"], 2201 2211 properties: { 2202 2212 playerId: { 2203 2203 - type: 'string', 2213 2213 + type: "string", 2204 2214 }, 2205 2215 fileId: { 2206 2206 - type: 'string', 2216 2216 + type: "string", 2207 2217 }, 2208 2218 }, 2209 2219 }, ··· 2212 2222 }, 2213 2223 AppRockskyPlayerPlay: { 2214 2224 lexicon: 1, 2215 2215 - id: 'app.rocksky.player.play', 2225 2225 + id: "app.rocksky.player.play", 2216 2226 defs: { 2217 2227 main: { 2218 2218 - type: 'procedure', 2219 2219 - description: 'Resume playback of the currently paused track', 2228 2228 + type: "procedure", 2229 2229 + description: "Resume playback of the currently paused track", 2220 2230 parameters: { 2221 2221 - type: 'params', 2231 2231 + type: "params", 2222 2232 properties: { 2223 2233 playerId: { 2224 2224 - type: 'string', 2234 2234 + type: "string", 2225 2235 }, 2226 2236 }, 2227 2237 }, ··· 2230 2240 }, 2231 2241 AppRockskyPlayerPrevious: { 2232 2242 lexicon: 1, 2233 2233 - id: 'app.rocksky.player.previous', 2243 2243 + id: "app.rocksky.player.previous", 2234 2244 defs: { 2235 2245 main: { 2236 2236 - type: 'procedure', 2237 2237 - description: 'Play the previous track in the queue', 2246 2246 + type: "procedure", 2247 2247 + description: "Play the previous track in the queue", 2238 2248 parameters: { 2239 2239 - type: 'params', 2249 2249 + type: "params", 2240 2250 properties: { 2241 2251 playerId: { 2242 2242 - type: 'string', 2252 2252 + type: "string", 2243 2253 }, 2244 2254 }, 2245 2255 }, ··· 2248 2258 }, 2249 2259 AppRockskyPlayerSeek: { 2250 2260 lexicon: 1, 2251 2251 - id: 'app.rocksky.player.seek', 2261 2261 + id: "app.rocksky.player.seek", 2252 2262 defs: { 2253 2263 main: { 2254 2254 - type: 'procedure', 2264 2264 + type: "procedure", 2255 2265 description: 2256 2256 - 'Seek to a specific position in the currently playing track', 2266 2266 + "Seek to a specific position in the currently playing track", 2257 2267 parameters: { 2258 2258 - type: 'params', 2259 2259 - required: ['position'], 2268 2268 + type: "params", 2269 2269 + required: ["position"], 2260 2270 properties: { 2261 2271 playerId: { 2262 2262 - type: 'string', 2272 2272 + type: "string", 2263 2273 }, 2264 2274 position: { 2265 2265 - type: 'integer', 2266 2266 - description: 'The position in seconds to seek to', 2275 2275 + type: "integer", 2276 2276 + description: "The position in seconds to seek to", 2267 2277 }, 2268 2278 }, 2269 2279 }, ··· 2272 2282 }, 2273 2283 AppRockskyPlaylistCreatePlaylist: { 2274 2284 lexicon: 1, 2275 2275 - id: 'app.rocksky.playlist.createPlaylist', 2285 2285 + id: "app.rocksky.playlist.createPlaylist", 2276 2286 defs: { 2277 2287 main: { 2278 2278 - type: 'procedure', 2279 2279 - description: 'Create a new playlist', 2288 2288 + type: "procedure", 2289 2289 + description: "Create a new playlist", 2280 2290 parameters: { 2281 2281 - type: 'params', 2282 2282 - required: ['name'], 2291 2291 + type: "params", 2292 2292 + required: ["name"], 2283 2293 properties: { 2284 2294 name: { 2285 2285 - type: 'string', 2286 2286 - description: 'The name of the playlist', 2295 2295 + type: "string", 2296 2296 + description: "The name of the playlist", 2287 2297 }, 2288 2298 description: { 2289 2289 - type: 'string', 2290 2290 - description: 'A brief description of the playlist', 2299 2299 + type: "string", 2300 2300 + description: "A brief description of the playlist", 2291 2301 }, 2292 2302 }, 2293 2303 }, ··· 2296 2306 }, 2297 2307 AppRockskyPlaylistDefs: { 2298 2308 lexicon: 1, 2299 2299 - id: 'app.rocksky.playlist.defs', 2309 2309 + id: "app.rocksky.playlist.defs", 2300 2310 defs: { 2301 2311 playlistViewDetailed: { 2302 2302 - type: 'object', 2312 2312 + type: "object", 2303 2313 description: 2304 2304 - 'Detailed view of a playlist, including its tracks and metadata', 2314 2314 + "Detailed view of a playlist, including its tracks and metadata", 2305 2315 properties: { 2306 2316 id: { 2307 2307 - type: 'string', 2308 2308 - description: 'The unique identifier of the playlist.', 2317 2317 + type: "string", 2318 2318 + description: "The unique identifier of the playlist.", 2309 2319 }, 2310 2320 title: { 2311 2311 - type: 'string', 2312 2312 - description: 'The title of the playlist.', 2321 2321 + type: "string", 2322 2322 + description: "The title of the playlist.", 2313 2323 }, 2314 2324 uri: { 2315 2315 - type: 'string', 2316 2316 - description: 'The URI of the playlist.', 2317 2317 - format: 'at-uri', 2325 2325 + type: "string", 2326 2326 + description: "The URI of the playlist.", 2327 2327 + format: "at-uri", 2318 2328 }, 2319 2329 curatorDid: { 2320 2320 - type: 'string', 2321 2321 - description: 'The DID of the curator of the playlist.', 2322 2322 - format: 'at-identifier', 2330 2330 + type: "string", 2331 2331 + description: "The DID of the curator of the playlist.", 2332 2332 + format: "at-identifier", 2323 2333 }, 2324 2334 curatorHandle: { 2325 2325 - type: 'string', 2326 2326 - description: 'The handle of the curator of the playlist.', 2327 2327 - format: 'at-identifier', 2335 2335 + type: "string", 2336 2336 + description: "The handle of the curator of the playlist.", 2337 2337 + format: "at-identifier", 2328 2338 }, 2329 2339 curatorName: { 2330 2330 - type: 'string', 2331 2331 - description: 'The name of the curator of the playlist.', 2340 2340 + type: "string", 2341 2341 + description: "The name of the curator of the playlist.", 2332 2342 }, 2333 2343 curatorAvatarUrl: { 2334 2334 - type: 'string', 2335 2335 - description: 'The URL of the avatar image of the curator.', 2336 2336 - format: 'uri', 2344 2344 + type: "string", 2345 2345 + description: "The URL of the avatar image of the curator.", 2346 2346 + format: "uri", 2337 2347 }, 2338 2348 description: { 2339 2339 - type: 'string', 2340 2340 - description: 'A description of the playlist.', 2349 2349 + type: "string", 2350 2350 + description: "A description of the playlist.", 2341 2351 }, 2342 2352 coverImageUrl: { 2343 2343 - type: 'string', 2344 2344 - description: 'The URL of the cover image for the playlist.', 2345 2345 - format: 'uri', 2353 2353 + type: "string", 2354 2354 + description: "The URL of the cover image for the playlist.", 2355 2355 + format: "uri", 2346 2356 }, 2347 2357 createdAt: { 2348 2348 - type: 'string', 2349 2349 - description: 'The date and time when the playlist was created.', 2350 2350 - format: 'datetime', 2358 2358 + type: "string", 2359 2359 + description: "The date and time when the playlist was created.", 2360 2360 + format: "datetime", 2351 2361 }, 2352 2362 tracks: { 2353 2353 - type: 'array', 2354 2354 - description: 'A list of tracks in the playlist.', 2363 2363 + type: "array", 2364 2364 + description: "A list of tracks in the playlist.", 2355 2365 items: { 2356 2356 - type: 'ref', 2357 2357 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 2366 2366 + type: "ref", 2367 2367 + ref: "lex:app.rocksky.song.defs#songViewBasic", 2358 2368 }, 2359 2369 }, 2360 2370 }, 2361 2371 }, 2362 2372 playlistViewBasic: { 2363 2363 - type: 'object', 2364 2364 - description: 'Basic view of a playlist, including its metadata', 2373 2373 + type: "object", 2374 2374 + description: "Basic view of a playlist, including its metadata", 2365 2375 properties: { 2366 2376 id: { 2367 2367 - type: 'string', 2368 2368 - description: 'The unique identifier of the playlist.', 2377 2377 + type: "string", 2378 2378 + description: "The unique identifier of the playlist.", 2369 2379 }, 2370 2380 title: { 2371 2371 - type: 'string', 2372 2372 - description: 'The title of the playlist.', 2381 2381 + type: "string", 2382 2382 + description: "The title of the playlist.", 2373 2383 }, 2374 2384 uri: { 2375 2375 - type: 'string', 2376 2376 - description: 'The URI of the playlist.', 2377 2377 - format: 'at-uri', 2385 2385 + type: "string", 2386 2386 + description: "The URI of the playlist.", 2387 2387 + format: "at-uri", 2378 2388 }, 2379 2389 curatorDid: { 2380 2380 - type: 'string', 2381 2381 - description: 'The DID of the curator of the playlist.', 2382 2382 - format: 'at-identifier', 2390 2390 + type: "string", 2391 2391 + description: "The DID of the curator of the playlist.", 2392 2392 + format: "at-identifier", 2383 2393 }, 2384 2394 curatorHandle: { 2385 2385 - type: 'string', 2386 2386 - description: 'The handle of the curator of the playlist.', 2387 2387 - format: 'at-identifier', 2395 2395 + type: "string", 2396 2396 + description: "The handle of the curator of the playlist.", 2397 2397 + format: "at-identifier", 2388 2398 }, 2389 2399 curatorName: { 2390 2390 - type: 'string', 2391 2391 - description: 'The name of the curator of the playlist.', 2400 2400 + type: "string", 2401 2401 + description: "The name of the curator of the playlist.", 2392 2402 }, 2393 2403 curatorAvatarUrl: { 2394 2394 - type: 'string', 2395 2395 - description: 'The URL of the avatar image of the curator.', 2396 2396 - format: 'uri', 2404 2404 + type: "string", 2405 2405 + description: "The URL of the avatar image of the curator.", 2406 2406 + format: "uri", 2397 2407 }, 2398 2408 description: { 2399 2399 - type: 'string', 2400 2400 - description: 'A description of the playlist.', 2409 2409 + type: "string", 2410 2410 + description: "A description of the playlist.", 2401 2411 }, 2402 2412 coverImageUrl: { 2403 2403 - type: 'string', 2404 2404 - description: 'The URL of the cover image for the playlist.', 2405 2405 - format: 'uri', 2413 2413 + type: "string", 2414 2414 + description: "The URL of the cover image for the playlist.", 2415 2415 + format: "uri", 2406 2416 }, 2407 2417 createdAt: { 2408 2408 - type: 'string', 2409 2409 - description: 'The date and time when the playlist was created.', 2410 2410 - format: 'datetime', 2418 2418 + type: "string", 2419 2419 + description: "The date and time when the playlist was created.", 2420 2420 + format: "datetime", 2411 2421 }, 2412 2422 trackCount: { 2413 2413 - type: 'integer', 2414 2414 - description: 'The number of tracks in the playlist.', 2423 2423 + type: "integer", 2424 2424 + description: "The number of tracks in the playlist.", 2415 2425 minimum: 0, 2416 2426 }, 2417 2427 }, ··· 2420 2430 }, 2421 2431 AppRockskyPlaylistGetPlaylist: { 2422 2432 lexicon: 1, 2423 2423 - id: 'app.rocksky.playlist.getPlaylist', 2433 2433 + id: "app.rocksky.playlist.getPlaylist", 2424 2434 defs: { 2425 2435 main: { 2426 2426 - type: 'query', 2427 2427 - description: 'Retrieve a playlist by its ID', 2436 2436 + type: "query", 2437 2437 + description: "Retrieve a playlist by its ID", 2428 2438 parameters: { 2429 2429 - type: 'params', 2430 2430 - required: ['uri'], 2439 2439 + type: "params", 2440 2440 + required: ["uri"], 2431 2441 properties: { 2432 2442 uri: { 2433 2433 - type: 'string', 2434 2434 - description: 'The URI of the playlist to retrieve.', 2435 2435 - format: 'at-uri', 2443 2443 + type: "string", 2444 2444 + description: "The URI of the playlist to retrieve.", 2445 2445 + format: "at-uri", 2436 2446 }, 2437 2447 }, 2438 2448 }, 2439 2449 output: { 2440 2440 - encoding: 'application/json', 2450 2450 + encoding: "application/json", 2441 2451 schema: { 2442 2442 - type: 'ref', 2443 2443 - ref: 'lex:app.rocksky.playlist.defs#playlistViewDetailed', 2452 2452 + type: "ref", 2453 2453 + ref: "lex:app.rocksky.playlist.defs#playlistViewDetailed", 2444 2454 }, 2445 2455 }, 2446 2456 }, ··· 2448 2458 }, 2449 2459 AppRockskyPlaylistGetPlaylists: { 2450 2460 lexicon: 1, 2451 2451 - id: 'app.rocksky.playlist.getPlaylists', 2461 2461 + id: "app.rocksky.playlist.getPlaylists", 2452 2462 defs: { 2453 2463 main: { 2454 2454 - type: 'query', 2455 2455 - description: 'Retrieve a list of playlists', 2464 2464 + type: "query", 2465 2465 + description: "Retrieve a list of playlists", 2456 2466 parameters: { 2457 2457 - type: 'params', 2467 2467 + type: "params", 2458 2468 properties: { 2459 2469 limit: { 2460 2460 - type: 'integer', 2461 2461 - description: 'The maximum number of playlists to return.', 2470 2470 + type: "integer", 2471 2471 + description: "The maximum number of playlists to return.", 2462 2472 }, 2463 2473 offset: { 2464 2464 - type: 'integer', 2474 2474 + type: "integer", 2465 2475 description: 2466 2466 - 'The offset for pagination, used to skip a number of playlists.', 2476 2476 + "The offset for pagination, used to skip a number of playlists.", 2467 2477 }, 2468 2478 }, 2469 2479 }, 2470 2480 output: { 2471 2471 - encoding: 'application/json', 2481 2481 + encoding: "application/json", 2472 2482 schema: { 2473 2473 - type: 'object', 2483 2483 + type: "object", 2474 2484 properties: { 2475 2485 playlists: { 2476 2476 - type: 'array', 2486 2486 + type: "array", 2477 2487 items: { 2478 2478 - type: 'ref', 2479 2479 - ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic', 2488 2488 + type: "ref", 2489 2489 + ref: "lex:app.rocksky.playlist.defs#playlistViewBasic", 2480 2490 }, 2481 2491 }, 2482 2492 }, ··· 2487 2497 }, 2488 2498 AppRockskyPlaylistInsertDirectory: { 2489 2499 lexicon: 1, 2490 2490 - id: 'app.rocksky.playlist.insertDirectory', 2500 2500 + id: "app.rocksky.playlist.insertDirectory", 2491 2501 defs: { 2492 2502 main: { 2493 2493 - type: 'procedure', 2494 2494 - description: 'Insert a directory into a playlist', 2503 2503 + type: "procedure", 2504 2504 + description: "Insert a directory into a playlist", 2495 2505 parameters: { 2496 2496 - type: 'params', 2497 2497 - required: ['uri', 'directory'], 2506 2506 + type: "params", 2507 2507 + required: ["uri", "directory"], 2498 2508 properties: { 2499 2509 uri: { 2500 2500 - type: 'string', 2501 2501 - description: 'The URI of the playlist to start', 2502 2502 - format: 'at-uri', 2510 2510 + type: "string", 2511 2511 + description: "The URI of the playlist to start", 2512 2512 + format: "at-uri", 2503 2513 }, 2504 2514 directory: { 2505 2505 - type: 'string', 2506 2506 - description: 'The directory (id) to insert into the playlist', 2515 2515 + type: "string", 2516 2516 + description: "The directory (id) to insert into the playlist", 2507 2517 }, 2508 2518 position: { 2509 2509 - type: 'integer', 2519 2519 + type: "integer", 2510 2520 description: 2511 2511 - 'The position in the playlist to insert the directory at, if not specified, the directory will be appended', 2521 2521 + "The position in the playlist to insert the directory at, if not specified, the directory will be appended", 2512 2522 }, 2513 2523 }, 2514 2524 }, ··· 2517 2527 }, 2518 2528 AppRockskyPlaylistInsertFiles: { 2519 2529 lexicon: 1, 2520 2520 - id: 'app.rocksky.playlist.insertFiles', 2530 2530 + id: "app.rocksky.playlist.insertFiles", 2521 2531 defs: { 2522 2532 main: { 2523 2523 - type: 'procedure', 2524 2524 - description: 'Insert files into a playlist', 2533 2533 + type: "procedure", 2534 2534 + description: "Insert files into a playlist", 2525 2535 parameters: { 2526 2526 - type: 'params', 2527 2527 - required: ['uri', 'files'], 2536 2536 + type: "params", 2537 2537 + required: ["uri", "files"], 2528 2538 properties: { 2529 2539 uri: { 2530 2530 - type: 'string', 2531 2531 - description: 'The URI of the playlist to start', 2532 2532 - format: 'at-uri', 2540 2540 + type: "string", 2541 2541 + description: "The URI of the playlist to start", 2542 2542 + format: "at-uri", 2533 2543 }, 2534 2544 files: { 2535 2535 - type: 'array', 2545 2545 + type: "array", 2536 2546 items: { 2537 2537 - type: 'string', 2538 2538 - description: 'List of file (id) to insert into the playlist', 2547 2547 + type: "string", 2548 2548 + description: "List of file (id) to insert into the playlist", 2539 2549 }, 2540 2550 }, 2541 2551 position: { 2542 2542 - type: 'integer', 2552 2552 + type: "integer", 2543 2553 description: 2544 2544 - 'The position in the playlist to insert the files at, if not specified, files will be appended', 2554 2554 + "The position in the playlist to insert the files at, if not specified, files will be appended", 2545 2555 }, 2546 2556 }, 2547 2557 }, ··· 2550 2560 }, 2551 2561 AppRockskyPlaylist: { 2552 2562 lexicon: 1, 2553 2553 - id: 'app.rocksky.playlist', 2563 2563 + id: "app.rocksky.playlist", 2554 2564 defs: { 2555 2565 main: { 2556 2556 - type: 'record', 2557 2557 - description: 'A declaration of a playlist.', 2558 2558 - key: 'tid', 2566 2566 + type: "record", 2567 2567 + description: "A declaration of a playlist.", 2568 2568 + key: "tid", 2559 2569 record: { 2560 2560 - type: 'object', 2561 2561 - required: ['name', 'createdAt'], 2570 2570 + type: "object", 2571 2571 + required: ["name", "createdAt"], 2562 2572 properties: { 2563 2573 name: { 2564 2564 - type: 'string', 2565 2565 - description: 'The name of the playlist.', 2574 2574 + type: "string", 2575 2575 + description: "The name of the playlist.", 2566 2576 minLength: 1, 2567 2577 maxLength: 512, 2568 2578 }, 2569 2579 description: { 2570 2570 - type: 'string', 2571 2571 - description: 'The playlist description.', 2580 2580 + type: "string", 2581 2581 + description: "The playlist description.", 2572 2582 minLength: 1, 2573 2583 maxLength: 256, 2574 2584 }, 2575 2585 picture: { 2576 2576 - type: 'blob', 2577 2577 - description: 'The picture of the playlist.', 2578 2578 - accept: ['image/png', 'image/jpeg'], 2586 2586 + type: "blob", 2587 2587 + description: "The picture of the playlist.", 2588 2588 + accept: ["image/png", "image/jpeg"], 2579 2589 maxSize: 2000000, 2580 2590 }, 2581 2591 tracks: { 2582 2582 - type: 'array', 2583 2583 - description: 'The tracks in the playlist.', 2592 2592 + type: "array", 2593 2593 + description: "The tracks in the playlist.", 2584 2594 items: { 2585 2585 - type: 'ref', 2586 2586 - ref: 'lex:app.rocksky.song#record', 2595 2595 + type: "ref", 2596 2596 + ref: "lex:app.rocksky.song#record", 2587 2597 }, 2588 2598 }, 2589 2599 createdAt: { 2590 2590 - type: 'string', 2591 2591 - description: 'The date the playlist was created.', 2592 2592 - format: 'datetime', 2600 2600 + type: "string", 2601 2601 + description: "The date the playlist was created.", 2602 2602 + format: "datetime", 2593 2603 }, 2594 2604 spotifyLink: { 2595 2595 - type: 'string', 2596 2596 - description: 'The Spotify link of the playlist.', 2605 2605 + type: "string", 2606 2606 + description: "The Spotify link of the playlist.", 2597 2607 }, 2598 2608 tidalLink: { 2599 2599 - type: 'string', 2600 2600 - description: 'The Tidal link of the playlist.', 2609 2609 + type: "string", 2610 2610 + description: "The Tidal link of the playlist.", 2601 2611 }, 2602 2612 youtubeLink: { 2603 2603 - type: 'string', 2604 2604 - description: 'The YouTube link of the playlist.', 2613 2613 + type: "string", 2614 2614 + description: "The YouTube link of the playlist.", 2605 2615 }, 2606 2616 appleMusicLink: { 2607 2607 - type: 'string', 2608 2608 - description: 'The Apple Music link of the playlist.', 2617 2617 + type: "string", 2618 2618 + description: "The Apple Music link of the playlist.", 2609 2619 }, 2610 2620 }, 2611 2621 }, ··· 2614 2624 }, 2615 2625 AppRockskyPlaylistRemovePlaylist: { 2616 2626 lexicon: 1, 2617 2617 - id: 'app.rocksky.playlist.removePlaylist', 2627 2627 + id: "app.rocksky.playlist.removePlaylist", 2618 2628 defs: { 2619 2629 main: { 2620 2620 - type: 'procedure', 2621 2621 - description: 'Remove a playlist', 2630 2630 + type: "procedure", 2631 2631 + description: "Remove a playlist", 2622 2632 parameters: { 2623 2623 - type: 'params', 2624 2624 - required: ['uri'], 2633 2633 + type: "params", 2634 2634 + required: ["uri"], 2625 2635 properties: { 2626 2636 uri: { 2627 2627 - type: 'string', 2628 2628 - description: 'The URI of the playlist to remove', 2629 2629 - format: 'at-uri', 2637 2637 + type: "string", 2638 2638 + description: "The URI of the playlist to remove", 2639 2639 + format: "at-uri", 2630 2640 }, 2631 2641 }, 2632 2642 }, ··· 2635 2645 }, 2636 2646 AppRockskyPlaylistRemoveTrack: { 2637 2647 lexicon: 1, 2638 2638 - id: 'app.rocksky.playlist.removeTrack', 2648 2648 + id: "app.rocksky.playlist.removeTrack", 2639 2649 defs: { 2640 2650 main: { 2641 2641 - type: 'procedure', 2642 2642 - description: 'Remove a track from a playlist', 2651 2651 + type: "procedure", 2652 2652 + description: "Remove a track from a playlist", 2643 2653 parameters: { 2644 2644 - type: 'params', 2645 2645 - required: ['uri', 'position'], 2654 2654 + type: "params", 2655 2655 + required: ["uri", "position"], 2646 2656 properties: { 2647 2657 uri: { 2648 2648 - type: 'string', 2649 2649 - description: 'The URI of the playlist to remove the track from', 2650 2650 - format: 'at-uri', 2658 2658 + type: "string", 2659 2659 + description: "The URI of the playlist to remove the track from", 2660 2660 + format: "at-uri", 2651 2661 }, 2652 2662 position: { 2653 2653 - type: 'integer', 2663 2663 + type: "integer", 2654 2664 description: 2655 2655 - 'The position of the track to remove in the playlist', 2665 2665 + "The position of the track to remove in the playlist", 2656 2666 }, 2657 2667 }, 2658 2668 }, ··· 2661 2671 }, 2662 2672 AppRockskyPlaylistStartPlaylist: { 2663 2673 lexicon: 1, 2664 2664 - id: 'app.rocksky.playlist.startPlaylist', 2674 2674 + id: "app.rocksky.playlist.startPlaylist", 2665 2675 defs: { 2666 2676 main: { 2667 2667 - type: 'procedure', 2668 2668 - description: 'Start a playlist', 2677 2677 + type: "procedure", 2678 2678 + description: "Start a playlist", 2669 2679 parameters: { 2670 2670 - type: 'params', 2671 2671 - required: ['uri'], 2680 2680 + type: "params", 2681 2681 + required: ["uri"], 2672 2682 properties: { 2673 2683 uri: { 2674 2674 - type: 'string', 2675 2675 - description: 'The URI of the playlist to start', 2676 2676 - format: 'at-uri', 2684 2684 + type: "string", 2685 2685 + description: "The URI of the playlist to start", 2686 2686 + format: "at-uri", 2677 2687 }, 2678 2688 shuffle: { 2679 2679 - type: 'boolean', 2680 2680 - description: 'Whether to shuffle the playlist when starting it', 2689 2689 + type: "boolean", 2690 2690 + description: "Whether to shuffle the playlist when starting it", 2681 2691 }, 2682 2692 position: { 2683 2683 - type: 'integer', 2693 2693 + type: "integer", 2684 2694 description: 2685 2685 - 'The position in the playlist to start from, if not specified, starts from the beginning', 2695 2695 + "The position in the playlist to start from, if not specified, starts from the beginning", 2686 2696 }, 2687 2697 }, 2688 2698 }, ··· 2691 2701 }, 2692 2702 AppRockskyRadioDefs: { 2693 2703 lexicon: 1, 2694 2694 - id: 'app.rocksky.radio.defs', 2704 2704 + id: "app.rocksky.radio.defs", 2695 2705 defs: { 2696 2706 radioViewBasic: { 2697 2697 - type: 'object', 2707 2707 + type: "object", 2698 2708 properties: { 2699 2709 id: { 2700 2700 - type: 'string', 2701 2701 - description: 'The unique identifier of the radio.', 2710 2710 + type: "string", 2711 2711 + description: "The unique identifier of the radio.", 2702 2712 }, 2703 2713 name: { 2704 2704 - type: 'string', 2705 2705 - description: 'The name of the radio.', 2714 2714 + type: "string", 2715 2715 + description: "The name of the radio.", 2706 2716 }, 2707 2717 description: { 2708 2708 - type: 'string', 2709 2709 - description: 'A brief description of the radio.', 2718 2718 + type: "string", 2719 2719 + description: "A brief description of the radio.", 2710 2720 }, 2711 2721 createdAt: { 2712 2712 - type: 'string', 2713 2713 - description: 'The date and time when the radio was created.', 2714 2714 - format: 'datetime', 2722 2722 + type: "string", 2723 2723 + description: "The date and time when the radio was created.", 2724 2724 + format: "datetime", 2715 2725 }, 2716 2726 }, 2717 2727 }, 2718 2728 radioViewDetailed: { 2719 2719 - type: 'object', 2729 2729 + type: "object", 2720 2730 properties: { 2721 2731 id: { 2722 2722 - type: 'string', 2723 2723 - description: 'The unique identifier of the radio.', 2732 2732 + type: "string", 2733 2733 + description: "The unique identifier of the radio.", 2724 2734 }, 2725 2735 name: { 2726 2726 - type: 'string', 2727 2727 - description: 'The name of the radio.', 2736 2736 + type: "string", 2737 2737 + description: "The name of the radio.", 2728 2738 }, 2729 2739 description: { 2730 2730 - type: 'string', 2731 2731 - description: 'A brief description of the radio.', 2740 2740 + type: "string", 2741 2741 + description: "A brief description of the radio.", 2732 2742 }, 2733 2743 website: { 2734 2734 - type: 'string', 2735 2735 - description: 'The website of the radio.', 2736 2736 - format: 'uri', 2744 2744 + type: "string", 2745 2745 + description: "The website of the radio.", 2746 2746 + format: "uri", 2737 2747 }, 2738 2748 url: { 2739 2739 - type: 'string', 2740 2740 - description: 'The streaming URL of the radio.', 2741 2741 - format: 'uri', 2749 2749 + type: "string", 2750 2750 + description: "The streaming URL of the radio.", 2751 2751 + format: "uri", 2742 2752 }, 2743 2753 genre: { 2744 2744 - type: 'string', 2745 2745 - description: 'The genre of the radio.', 2754 2754 + type: "string", 2755 2755 + description: "The genre of the radio.", 2746 2756 }, 2747 2757 logo: { 2748 2748 - type: 'string', 2749 2749 - description: 'The logo of the radio station.', 2758 2758 + type: "string", 2759 2759 + description: "The logo of the radio station.", 2750 2760 }, 2751 2761 createdAt: { 2752 2752 - type: 'string', 2753 2753 - description: 'The date and time when the radio was created.', 2754 2754 - format: 'datetime', 2762 2762 + type: "string", 2763 2763 + description: "The date and time when the radio was created.", 2764 2764 + format: "datetime", 2755 2765 }, 2756 2766 }, 2757 2767 }, ··· 2759 2769 }, 2760 2770 AppRockskyRadio: { 2761 2771 lexicon: 1, 2762 2762 - id: 'app.rocksky.radio', 2772 2772 + id: "app.rocksky.radio", 2763 2773 defs: { 2764 2774 main: { 2765 2765 - type: 'record', 2766 2766 - description: 'A declaration of a radio station.', 2767 2767 - key: 'tid', 2775 2775 + type: "record", 2776 2776 + description: "A declaration of a radio station.", 2777 2777 + key: "tid", 2768 2778 record: { 2769 2769 - type: 'object', 2770 2770 - required: ['name', 'url', 'createdAt'], 2779 2779 + type: "object", 2780 2780 + required: ["name", "url", "createdAt"], 2771 2781 properties: { 2772 2782 name: { 2773 2773 - type: 'string', 2774 2774 - description: 'The name of the radio station.', 2783 2783 + type: "string", 2784 2784 + description: "The name of the radio station.", 2775 2785 minLength: 1, 2776 2786 maxLength: 512, 2777 2787 }, 2778 2788 url: { 2779 2779 - type: 'string', 2780 2780 - description: 'The URL of the radio station.', 2781 2781 - format: 'uri', 2789 2789 + type: "string", 2790 2790 + description: "The URL of the radio station.", 2791 2791 + format: "uri", 2782 2792 }, 2783 2793 description: { 2784 2784 - type: 'string', 2785 2785 - description: 'A description of the radio station.', 2794 2794 + type: "string", 2795 2795 + description: "A description of the radio station.", 2786 2796 minLength: 1, 2787 2797 maxLength: 1000, 2788 2798 }, 2789 2799 genre: { 2790 2790 - type: 'string', 2791 2791 - description: 'The genre of the radio station.', 2800 2800 + type: "string", 2801 2801 + description: "The genre of the radio station.", 2792 2802 minLength: 1, 2793 2803 maxLength: 256, 2794 2804 }, 2795 2805 logo: { 2796 2796 - type: 'blob', 2797 2797 - description: 'The logo of the radio station.', 2798 2798 - accept: ['image/png', 'image/jpeg'], 2806 2806 + type: "blob", 2807 2807 + description: "The logo of the radio station.", 2808 2808 + accept: ["image/png", "image/jpeg"], 2799 2809 maxSize: 2000000, 2800 2810 }, 2801 2811 website: { 2802 2802 - type: 'string', 2803 2803 - description: 'The website of the radio station.', 2804 2804 - format: 'uri', 2812 2812 + type: "string", 2813 2813 + description: "The website of the radio station.", 2814 2814 + format: "uri", 2805 2815 }, 2806 2816 createdAt: { 2807 2807 - type: 'string', 2808 2808 - description: 'The date when the radio station was created.', 2809 2809 - format: 'datetime', 2817 2817 + type: "string", 2818 2818 + description: "The date when the radio station was created.", 2819 2819 + format: "datetime", 2810 2820 }, 2811 2821 }, 2812 2822 }, ··· 2815 2825 }, 2816 2826 AppRockskyScrobbleCreateScrobble: { 2817 2827 lexicon: 1, 2818 2818 - id: 'app.rocksky.scrobble.createScrobble', 2828 2828 + id: "app.rocksky.scrobble.createScrobble", 2819 2829 defs: { 2820 2830 main: { 2821 2821 - type: 'procedure', 2822 2822 - description: 'Create a new scrobble', 2831 2831 + type: "procedure", 2832 2832 + description: "Create a new scrobble", 2823 2833 input: { 2824 2824 - encoding: 'application/json', 2834 2834 + encoding: "application/json", 2825 2835 schema: { 2826 2826 - type: 'object', 2827 2827 - required: ['title', 'artist'], 2836 2836 + type: "object", 2837 2837 + required: ["title", "artist"], 2828 2838 properties: { 2829 2839 title: { 2830 2830 - type: 'string', 2831 2831 - description: 'The title of the track being scrobbled', 2840 2840 + type: "string", 2841 2841 + description: "The title of the track being scrobbled", 2832 2842 }, 2833 2843 artist: { 2834 2834 - type: 'string', 2835 2835 - description: 'The artist of the track being scrobbled', 2844 2844 + type: "string", 2845 2845 + description: "The artist of the track being scrobbled", 2836 2846 }, 2837 2847 album: { 2838 2838 - type: 'string', 2839 2839 - description: 'The album of the track being scrobbled', 2848 2848 + type: "string", 2849 2849 + description: "The album of the track being scrobbled", 2840 2850 }, 2841 2851 duration: { 2842 2842 - type: 'integer', 2843 2843 - description: 'The duration of the track in seconds', 2852 2852 + type: "integer", 2853 2853 + description: "The duration of the track in seconds", 2844 2854 }, 2845 2855 mbId: { 2846 2846 - type: 'string', 2847 2847 - description: 'The MusicBrainz ID of the track, if available', 2856 2856 + type: "string", 2857 2857 + description: "The MusicBrainz ID of the track, if available", 2848 2858 }, 2849 2859 albumArt: { 2850 2850 - type: 'string', 2851 2851 - description: 'The URL of the album art for the track', 2852 2852 - format: 'uri', 2860 2860 + type: "string", 2861 2861 + description: "The URL of the album art for the track", 2862 2862 + format: "uri", 2853 2863 }, 2854 2864 trackNumber: { 2855 2855 - type: 'integer', 2856 2856 - description: 'The track number of the track in the album', 2865 2865 + type: "integer", 2866 2866 + description: "The track number of the track in the album", 2857 2867 }, 2858 2868 releaseDate: { 2859 2859 - type: 'string', 2869 2869 + type: "string", 2860 2870 description: 2861 2861 - 'The release date of the track, formatted as YYYY-MM-DD', 2871 2871 + "The release date of the track, formatted as YYYY-MM-DD", 2862 2872 }, 2863 2873 year: { 2864 2864 - type: 'integer', 2865 2865 - description: 'The year the track was released', 2874 2874 + type: "integer", 2875 2875 + description: "The year the track was released", 2866 2876 }, 2867 2877 discNumber: { 2868 2868 - type: 'integer', 2878 2878 + type: "integer", 2869 2879 description: 2870 2870 - 'The disc number of the track in the album, if applicable', 2880 2880 + "The disc number of the track in the album, if applicable", 2871 2881 }, 2872 2882 lyrics: { 2873 2873 - type: 'string', 2874 2874 - description: 'The lyrics of the track, if available', 2883 2883 + type: "string", 2884 2884 + description: "The lyrics of the track, if available", 2875 2885 }, 2876 2886 composer: { 2877 2877 - type: 'string', 2878 2878 - description: 'The composer of the track, if available', 2887 2887 + type: "string", 2888 2888 + description: "The composer of the track, if available", 2879 2889 }, 2880 2890 copyrightMessage: { 2881 2881 - type: 'string', 2891 2891 + type: "string", 2882 2892 description: 2883 2883 - 'The copyright message for the track, if available', 2893 2893 + "The copyright message for the track, if available", 2884 2894 }, 2885 2895 label: { 2886 2886 - type: 'string', 2887 2887 - description: 'The record label of the track, if available', 2896 2896 + type: "string", 2897 2897 + description: "The record label of the track, if available", 2888 2898 }, 2889 2899 artistPicture: { 2890 2890 - type: 'string', 2900 2900 + type: "string", 2891 2901 description: "The URL of the artist's picture, if available", 2892 2892 - format: 'uri', 2902 2902 + format: "uri", 2893 2903 }, 2894 2904 spotifyLink: { 2895 2895 - type: 'string', 2896 2896 - description: 'The Spotify link for the track, if available', 2897 2897 - format: 'uri', 2905 2905 + type: "string", 2906 2906 + description: "The Spotify link for the track, if available", 2907 2907 + format: "uri", 2898 2908 }, 2899 2909 lastfmLink: { 2900 2900 - type: 'string', 2901 2901 - description: 'The Last.fm link for the track, if available', 2902 2902 - format: 'uri', 2910 2910 + type: "string", 2911 2911 + description: "The Last.fm link for the track, if available", 2912 2912 + format: "uri", 2903 2913 }, 2904 2914 tidalLink: { 2905 2905 - type: 'string', 2906 2906 - description: 'The Tidal link for the track, if available', 2907 2907 - format: 'uri', 2915 2915 + type: "string", 2916 2916 + description: "The Tidal link for the track, if available", 2917 2917 + format: "uri", 2908 2918 }, 2909 2919 appleMusicLink: { 2910 2910 - type: 'string', 2911 2911 - description: 'The Apple Music link for the track, if available', 2912 2912 - format: 'uri', 2920 2920 + type: "string", 2921 2921 + description: "The Apple Music link for the track, if available", 2922 2922 + format: "uri", 2913 2923 }, 2914 2924 youtubeLink: { 2915 2915 - type: 'string', 2916 2916 - description: 'The Youtube link for the track, if available', 2917 2917 - format: 'uri', 2925 2925 + type: "string", 2926 2926 + description: "The Youtube link for the track, if available", 2927 2927 + format: "uri", 2918 2928 }, 2919 2929 deezerLink: { 2920 2920 - type: 'string', 2921 2921 - description: 'The Deezer link for the track, if available', 2922 2922 - format: 'uri', 2930 2930 + type: "string", 2931 2931 + description: "The Deezer link for the track, if available", 2932 2932 + format: "uri", 2923 2933 }, 2924 2934 timestamp: { 2925 2925 - type: 'integer', 2935 2935 + type: "integer", 2926 2936 description: 2927 2927 - 'The timestamp of the scrobble in milliseconds since epoch', 2937 2937 + "The timestamp of the scrobble in milliseconds since epoch", 2928 2938 }, 2929 2939 }, 2930 2940 }, 2931 2941 }, 2932 2942 output: { 2933 2933 - encoding: 'application/json', 2943 2943 + encoding: "application/json", 2934 2944 schema: { 2935 2935 - type: 'ref', 2936 2936 - ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic', 2945 2945 + type: "ref", 2946 2946 + ref: "lex:app.rocksky.scrobble.defs#scrobbleViewBasic", 2937 2947 }, 2938 2948 }, 2939 2949 }, ··· 2941 2951 }, 2942 2952 AppRockskyScrobbleDefs: { 2943 2953 lexicon: 1, 2944 2944 - id: 'app.rocksky.scrobble.defs', 2954 2954 + id: "app.rocksky.scrobble.defs", 2945 2955 defs: { 2946 2956 scrobbleViewBasic: { 2947 2947 - type: 'object', 2957 2957 + type: "object", 2948 2958 properties: { 2949 2959 id: { 2950 2950 - type: 'string', 2951 2951 - description: 'The unique identifier of the scrobble.', 2960 2960 + type: "string", 2961 2961 + description: "The unique identifier of the scrobble.", 2952 2962 }, 2953 2963 user: { 2954 2954 - type: 'string', 2955 2955 - description: 'The handle of the user who created the scrobble.', 2964 2964 + type: "string", 2965 2965 + description: "The handle of the user who created the scrobble.", 2956 2966 }, 2957 2967 userDisplayName: { 2958 2958 - type: 'string', 2968 2968 + type: "string", 2959 2969 description: 2960 2960 - 'The display name of the user who created the scrobble.', 2970 2970 + "The display name of the user who created the scrobble.", 2961 2971 }, 2962 2972 userAvatar: { 2963 2963 - type: 'string', 2964 2964 - description: 'The avatar URL of the user who created the scrobble.', 2965 2965 - format: 'uri', 2973 2973 + type: "string", 2974 2974 + description: "The avatar URL of the user who created the scrobble.", 2975 2975 + format: "uri", 2966 2976 }, 2967 2977 title: { 2968 2968 - type: 'string', 2969 2969 - description: 'The title of the scrobble.', 2978 2978 + type: "string", 2979 2979 + description: "The title of the scrobble.", 2970 2980 }, 2971 2981 artist: { 2972 2972 - type: 'string', 2973 2973 - description: 'The artist of the song.', 2982 2982 + type: "string", 2983 2983 + description: "The artist of the song.", 2974 2984 }, 2975 2985 artistUri: { 2976 2976 - type: 'string', 2977 2977 - description: 'The URI of the artist.', 2978 2978 - format: 'at-uri', 2986 2986 + type: "string", 2987 2987 + description: "The URI of the artist.", 2988 2988 + format: "at-uri", 2979 2989 }, 2980 2990 album: { 2981 2981 - type: 'string', 2982 2982 - description: 'The album of the song.', 2991 2991 + type: "string", 2992 2992 + description: "The album of the song.", 2983 2993 }, 2984 2994 albumUri: { 2985 2985 - type: 'string', 2986 2986 - description: 'The URI of the album.', 2987 2987 - format: 'at-uri', 2995 2995 + type: "string", 2996 2996 + description: "The URI of the album.", 2997 2997 + format: "at-uri", 2988 2998 }, 2989 2999 cover: { 2990 2990 - type: 'string', 2991 2991 - description: 'The album art URL of the song.', 2992 2992 - format: 'uri', 3000 3000 + type: "string", 3001 3001 + description: "The album art URL of the song.", 3002 3002 + format: "uri", 2993 3003 }, 2994 3004 date: { 2995 2995 - type: 'string', 2996 2996 - description: 'The timestamp when the scrobble was created.', 2997 2997 - format: 'datetime', 3005 3005 + type: "string", 3006 3006 + description: "The timestamp when the scrobble was created.", 3007 3007 + format: "datetime", 2998 3008 }, 2999 3009 uri: { 3000 3000 - type: 'string', 3001 3001 - description: 'The URI of the scrobble.', 3002 3002 - format: 'uri', 3010 3010 + type: "string", 3011 3011 + description: "The URI of the scrobble.", 3012 3012 + format: "uri", 3003 3013 }, 3004 3014 sha256: { 3005 3005 - type: 'string', 3006 3006 - description: 'The SHA256 hash of the scrobble data.', 3015 3015 + type: "string", 3016 3016 + description: "The SHA256 hash of the scrobble data.", 3007 3017 }, 3008 3018 }, 3009 3019 }, 3010 3020 scrobbleViewDetailed: { 3011 3011 - type: 'object', 3021 3021 + type: "object", 3012 3022 properties: { 3013 3023 id: { 3014 3014 - type: 'string', 3015 3015 - description: 'The unique identifier of the scrobble.', 3024 3024 + type: "string", 3025 3025 + description: "The unique identifier of the scrobble.", 3016 3026 }, 3017 3027 user: { 3018 3018 - type: 'string', 3019 3019 - description: 'The handle of the user who created the scrobble.', 3028 3028 + type: "string", 3029 3029 + description: "The handle of the user who created the scrobble.", 3020 3030 }, 3021 3031 title: { 3022 3022 - type: 'string', 3023 3023 - description: 'The title of the scrobble.', 3032 3032 + type: "string", 3033 3033 + description: "The title of the scrobble.", 3024 3034 }, 3025 3035 artist: { 3026 3026 - type: 'string', 3027 3027 - description: 'The artist of the song.', 3036 3036 + type: "string", 3037 3037 + description: "The artist of the song.", 3028 3038 }, 3029 3039 artistUri: { 3030 3030 - type: 'string', 3031 3031 - description: 'The URI of the artist.', 3032 3032 - format: 'at-uri', 3040 3040 + type: "string", 3041 3041 + description: "The URI of the artist.", 3042 3042 + format: "at-uri", 3033 3043 }, 3034 3044 album: { 3035 3035 - type: 'string', 3036 3036 - description: 'The album of the song.', 3045 3045 + type: "string", 3046 3046 + description: "The album of the song.", 3037 3047 }, 3038 3048 albumUri: { 3039 3039 - type: 'string', 3040 3040 - description: 'The URI of the album.', 3041 3041 - format: 'at-uri', 3049 3049 + type: "string", 3050 3050 + description: "The URI of the album.", 3051 3051 + format: "at-uri", 3042 3052 }, 3043 3053 cover: { 3044 3044 - type: 'string', 3045 3045 - description: 'The album art URL of the song.', 3046 3046 - format: 'uri', 3054 3054 + type: "string", 3055 3055 + description: "The album art URL of the song.", 3056 3056 + format: "uri", 3047 3057 }, 3048 3058 date: { 3049 3049 - type: 'string', 3050 3050 - description: 'The timestamp when the scrobble was created.', 3051 3051 - format: 'datetime', 3059 3059 + type: "string", 3060 3060 + description: "The timestamp when the scrobble was created.", 3061 3061 + format: "datetime", 3052 3062 }, 3053 3063 uri: { 3054 3054 - type: 'string', 3055 3055 - description: 'The URI of the scrobble.', 3056 3056 - format: 'uri', 3064 3064 + type: "string", 3065 3065 + description: "The URI of the scrobble.", 3066 3066 + format: "uri", 3057 3067 }, 3058 3068 sha256: { 3059 3059 - type: 'string', 3060 3060 - description: 'The SHA256 hash of the scrobble data.', 3069 3069 + type: "string", 3070 3070 + description: "The SHA256 hash of the scrobble data.", 3061 3071 }, 3062 3072 listeners: { 3063 3063 - type: 'integer', 3064 3064 - description: 'The number of listeners', 3073 3073 + type: "integer", 3074 3074 + description: "The number of listeners", 3065 3075 }, 3066 3076 scrobbles: { 3067 3067 - type: 'integer', 3068 3068 - description: 'The number of scrobbles for this song', 3077 3077 + type: "integer", 3078 3078 + description: "The number of scrobbles for this song", 3069 3079 }, 3070 3080 }, 3071 3081 }, ··· 3073 3083 }, 3074 3084 AppRockskyScrobbleGetScrobble: { 3075 3085 lexicon: 1, 3076 3076 - id: 'app.rocksky.scrobble.getScrobble', 3086 3086 + id: "app.rocksky.scrobble.getScrobble", 3077 3087 defs: { 3078 3088 main: { 3079 3079 - type: 'query', 3080 3080 - description: 'Get a scrobble by its unique identifier', 3089 3089 + type: "query", 3090 3090 + description: "Get a scrobble by its unique identifier", 3081 3091 parameters: { 3082 3082 - type: 'params', 3083 3083 - required: ['uri'], 3092 3092 + type: "params", 3093 3093 + required: ["uri"], 3084 3094 properties: { 3085 3095 uri: { 3086 3086 - type: 'string', 3087 3087 - description: 'The unique identifier of the scrobble', 3088 3088 - format: 'at-uri', 3096 3096 + type: "string", 3097 3097 + description: "The unique identifier of the scrobble", 3098 3098 + format: "at-uri", 3089 3099 }, 3090 3100 }, 3091 3101 }, 3092 3102 output: { 3093 3093 - encoding: 'application/json', 3103 3103 + encoding: "application/json", 3094 3104 schema: { 3095 3095 - type: 'ref', 3096 3096 - ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewDetailed', 3105 3105 + type: "ref", 3106 3106 + ref: "lex:app.rocksky.scrobble.defs#scrobbleViewDetailed", 3097 3107 }, 3098 3108 }, 3099 3109 }, ··· 3101 3111 }, 3102 3112 AppRockskyScrobbleGetScrobbles: { 3103 3113 lexicon: 1, 3104 3104 - id: 'app.rocksky.scrobble.getScrobbles', 3114 3114 + id: "app.rocksky.scrobble.getScrobbles", 3105 3115 defs: { 3106 3116 main: { 3107 3107 - type: 'query', 3108 3108 - description: 'Get scrobbles all scrobbles', 3117 3117 + type: "query", 3118 3118 + description: "Get scrobbles all scrobbles", 3109 3119 parameters: { 3110 3110 - type: 'params', 3120 3120 + type: "params", 3111 3121 properties: { 3112 3122 did: { 3113 3113 - type: 'string', 3114 3114 - description: 'The DID or handle of the actor', 3115 3115 - format: 'at-identifier', 3123 3123 + type: "string", 3124 3124 + description: "The DID or handle of the actor", 3125 3125 + format: "at-identifier", 3116 3126 }, 3117 3127 limit: { 3118 3118 - type: 'integer', 3119 3119 - description: 'The maximum number of scrobbles to return', 3128 3128 + type: "integer", 3129 3129 + description: "The maximum number of scrobbles to return", 3120 3130 minimum: 1, 3121 3131 }, 3122 3132 offset: { 3123 3123 - type: 'integer', 3124 3124 - description: 'The offset for pagination', 3133 3133 + type: "integer", 3134 3134 + description: "The offset for pagination", 3125 3135 minimum: 0, 3126 3136 }, 3127 3137 }, 3128 3138 }, 3129 3139 output: { 3130 3130 - encoding: 'application/json', 3140 3140 + encoding: "application/json", 3131 3141 schema: { 3132 3132 - type: 'object', 3142 3142 + type: "object", 3133 3143 properties: { 3134 3144 scrobbles: { 3135 3135 - type: 'array', 3145 3145 + type: "array", 3136 3146 items: { 3137 3137 - type: 'ref', 3138 3138 - ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic', 3147 3147 + type: "ref", 3148 3148 + ref: "lex:app.rocksky.scrobble.defs#scrobbleViewBasic", 3139 3149 }, 3140 3150 }, 3141 3151 }, ··· 3146 3156 }, 3147 3157 AppRockskyScrobble: { 3148 3158 lexicon: 1, 3149 3149 - id: 'app.rocksky.scrobble', 3159 3159 + id: "app.rocksky.scrobble", 3150 3160 defs: { 3151 3161 main: { 3152 3152 - type: 'record', 3153 3153 - description: 'A declaration of a scrobble.', 3154 3154 - key: 'tid', 3162 3162 + type: "record", 3163 3163 + description: "A declaration of a scrobble.", 3164 3164 + key: "tid", 3155 3165 record: { 3156 3156 - type: 'object', 3166 3166 + type: "object", 3157 3167 required: [ 3158 3158 - 'title', 3159 3159 - 'artist', 3160 3160 - 'album', 3161 3161 - 'albumArtist', 3162 3162 - 'duration', 3163 3163 - 'createdAt', 3168 3168 + "title", 3169 3169 + "artist", 3170 3170 + "album", 3171 3171 + "albumArtist", 3172 3172 + "duration", 3173 3173 + "createdAt", 3164 3174 ], 3165 3175 properties: { 3166 3176 title: { 3167 3167 - type: 'string', 3168 3168 - description: 'The title of the song.', 3177 3177 + type: "string", 3178 3178 + description: "The title of the song.", 3169 3179 minLength: 1, 3170 3180 maxLength: 512, 3171 3181 }, 3172 3182 artist: { 3173 3173 - type: 'string', 3174 3174 - description: 'The artist of the song.', 3183 3183 + type: "string", 3184 3184 + description: "The artist of the song.", 3175 3185 minLength: 1, 3176 3186 maxLength: 256, 3177 3187 }, 3178 3188 albumArtist: { 3179 3179 - type: 'string', 3180 3180 - description: 'The album artist of the song.', 3189 3189 + type: "string", 3190 3190 + description: "The album artist of the song.", 3181 3191 minLength: 1, 3182 3192 maxLength: 256, 3183 3193 }, 3184 3194 album: { 3185 3185 - type: 'string', 3186 3186 - description: 'The album of the song.', 3195 3195 + type: "string", 3196 3196 + description: "The album of the song.", 3187 3197 minLength: 1, 3188 3198 maxLength: 256, 3189 3199 }, 3190 3200 duration: { 3191 3191 - type: 'integer', 3192 3192 - description: 'The duration of the song in seconds.', 3201 3201 + type: "integer", 3202 3202 + description: "The duration of the song in seconds.", 3193 3203 minimum: 1, 3194 3204 }, 3195 3205 trackNumber: { 3196 3196 - type: 'integer', 3197 3197 - description: 'The track number of the song in the album.', 3206 3206 + type: "integer", 3207 3207 + description: "The track number of the song in the album.", 3198 3208 minimum: 1, 3199 3209 }, 3200 3210 discNumber: { 3201 3201 - type: 'integer', 3202 3202 - description: 'The disc number of the song in the album.', 3211 3211 + type: "integer", 3212 3212 + description: "The disc number of the song in the album.", 3203 3213 minimum: 1, 3204 3214 }, 3205 3215 releaseDate: { 3206 3206 - type: 'string', 3207 3207 - description: 'The release date of the song.', 3208 3208 - format: 'datetime', 3216 3216 + type: "string", 3217 3217 + description: "The release date of the song.", 3218 3218 + format: "datetime", 3209 3219 }, 3210 3220 year: { 3211 3211 - type: 'integer', 3212 3212 - description: 'The year the song was released.', 3221 3221 + type: "integer", 3222 3222 + description: "The year the song was released.", 3213 3223 }, 3214 3224 genre: { 3215 3215 - type: 'string', 3216 3216 - description: 'The genre of the song.', 3225 3225 + type: "string", 3226 3226 + description: "The genre of the song.", 3217 3227 maxLength: 256, 3218 3228 }, 3219 3229 tags: { 3220 3220 - type: 'array', 3221 3221 - description: 'The tags of the song.', 3230 3230 + type: "array", 3231 3231 + description: "The tags of the song.", 3222 3232 items: { 3223 3223 - type: 'string', 3233 3233 + type: "string", 3224 3234 minLength: 1, 3225 3235 maxLength: 256, 3226 3236 }, 3227 3237 }, 3228 3238 composer: { 3229 3229 - type: 'string', 3230 3230 - description: 'The composer of the song.', 3239 3239 + type: "string", 3240 3240 + description: "The composer of the song.", 3231 3241 maxLength: 256, 3232 3242 }, 3233 3243 lyrics: { 3234 3234 - type: 'string', 3235 3235 - description: 'The lyrics of the song.', 3244 3244 + type: "string", 3245 3245 + description: "The lyrics of the song.", 3236 3246 maxLength: 10000, 3237 3247 }, 3238 3248 copyrightMessage: { 3239 3239 - type: 'string', 3240 3240 - description: 'The copyright message of the song.', 3249 3249 + type: "string", 3250 3250 + description: "The copyright message of the song.", 3241 3251 maxLength: 256, 3242 3252 }, 3243 3253 wiki: { 3244 3244 - type: 'string', 3245 3245 - description: 'Informations about the song', 3254 3254 + type: "string", 3255 3255 + description: "Informations about the song", 3246 3256 maxLength: 10000, 3247 3257 }, 3248 3258 albumArt: { 3249 3249 - type: 'blob', 3250 3250 - description: 'The album art of the song.', 3251 3251 - accept: ['image/png', 'image/jpeg'], 3259 3259 + type: "blob", 3260 3260 + description: "The album art of the song.", 3261 3261 + accept: ["image/png", "image/jpeg"], 3252 3262 maxSize: 2000000, 3253 3263 }, 3264 3264 + albumArtUrl: { 3265 3265 + type: "string", 3266 3266 + description: "The URL of the album art of the song.", 3267 3267 + format: "uri", 3268 3268 + }, 3254 3269 youtubeLink: { 3255 3255 - type: 'string', 3256 3256 - description: 'The YouTube link of the song.', 3257 3257 - format: 'uri', 3270 3270 + type: "string", 3271 3271 + description: "The YouTube link of the song.", 3272 3272 + format: "uri", 3258 3273 }, 3259 3274 spotifyLink: { 3260 3260 - type: 'string', 3261 3261 - description: 'The Spotify link of the song.', 3262 3262 - format: 'uri', 3275 3275 + type: "string", 3276 3276 + description: "The Spotify link of the song.", 3277 3277 + format: "uri", 3263 3278 }, 3264 3279 tidalLink: { 3265 3265 - type: 'string', 3266 3266 - description: 'The Tidal link of the song.', 3267 3267 - format: 'uri', 3280 3280 + type: "string", 3281 3281 + description: "The Tidal link of the song.", 3282 3282 + format: "uri", 3268 3283 }, 3269 3284 appleMusicLink: { 3270 3270 - type: 'string', 3271 3271 - description: 'The Apple Music link of the song.', 3272 3272 - format: 'uri', 3285 3285 + type: "string", 3286 3286 + description: "The Apple Music link of the song.", 3287 3287 + format: "uri", 3273 3288 }, 3274 3289 createdAt: { 3275 3275 - type: 'string', 3276 3276 - description: 'The date when the song was created.', 3277 3277 - format: 'datetime', 3290 3290 + type: "string", 3291 3291 + description: "The date when the song was created.", 3292 3292 + format: "datetime", 3278 3293 }, 3279 3294 mbid: { 3280 3280 - type: 'string', 3281 3281 - description: 'The MusicBrainz ID of the song.', 3295 3295 + type: "string", 3296 3296 + description: "The MusicBrainz ID of the song.", 3282 3297 }, 3283 3298 label: { 3284 3284 - type: 'string', 3285 3285 - description: 'The label of the song.', 3299 3299 + type: "string", 3300 3300 + description: "The label of the song.", 3286 3301 maxLength: 256, 3287 3302 }, 3288 3303 }, ··· 3292 3307 }, 3293 3308 AppRockskyShoutCreateShout: { 3294 3309 lexicon: 1, 3295 3295 - id: 'app.rocksky.shout.createShout', 3310 3310 + id: "app.rocksky.shout.createShout", 3296 3311 defs: { 3297 3312 main: { 3298 3298 - type: 'procedure', 3299 3299 - description: 'Create a new shout', 3313 3313 + type: "procedure", 3314 3314 + description: "Create a new shout", 3300 3315 input: { 3301 3301 - encoding: 'application/json', 3316 3316 + encoding: "application/json", 3302 3317 schema: { 3303 3303 - type: 'object', 3318 3318 + type: "object", 3304 3319 properties: { 3305 3320 message: { 3306 3306 - type: 'string', 3307 3307 - description: 'The content of the shout', 3321 3321 + type: "string", 3322 3322 + description: "The content of the shout", 3308 3323 minLength: 1, 3309 3324 }, 3310 3325 }, 3311 3326 }, 3312 3327 }, 3313 3328 output: { 3314 3314 - encoding: 'application/json', 3329 3329 + encoding: "application/json", 3315 3330 schema: { 3316 3316 - type: 'ref', 3317 3317 - ref: 'lex:app.rocksky.shout.defs#shoutView', 3331 3331 + type: "ref", 3332 3332 + ref: "lex:app.rocksky.shout.defs#shoutView", 3318 3333 }, 3319 3334 }, 3320 3335 }, ··· 3322 3337 }, 3323 3338 AppRockskyShoutDefs: { 3324 3339 lexicon: 1, 3325 3325 - id: 'app.rocksky.shout.defs', 3340 3340 + id: "app.rocksky.shout.defs", 3326 3341 defs: { 3327 3342 author: { 3328 3328 - type: 'object', 3343 3343 + type: "object", 3329 3344 properties: { 3330 3345 id: { 3331 3331 - type: 'string', 3332 3332 - description: 'The unique identifier of the author.', 3346 3346 + type: "string", 3347 3347 + description: "The unique identifier of the author.", 3333 3348 }, 3334 3349 did: { 3335 3335 - type: 'string', 3336 3336 - description: 'The decentralized identifier (DID) of the author.', 3337 3337 - format: 'at-identifier', 3350 3350 + type: "string", 3351 3351 + description: "The decentralized identifier (DID) of the author.", 3352 3352 + format: "at-identifier", 3338 3353 }, 3339 3354 handle: { 3340 3340 - type: 'string', 3341 3341 - description: 'The handle of the author.', 3342 3342 - format: 'at-identifier', 3355 3355 + type: "string", 3356 3356 + description: "The handle of the author.", 3357 3357 + format: "at-identifier", 3343 3358 }, 3344 3359 displayName: { 3345 3345 - type: 'string', 3346 3346 - description: 'The display name of the author.', 3360 3360 + type: "string", 3361 3361 + description: "The display name of the author.", 3347 3362 }, 3348 3363 avatar: { 3349 3349 - type: 'string', 3364 3364 + type: "string", 3350 3365 description: "The URL of the author's avatar image.", 3351 3351 - format: 'uri', 3366 3366 + format: "uri", 3352 3367 }, 3353 3368 }, 3354 3369 }, 3355 3370 shoutView: { 3356 3356 - type: 'object', 3371 3371 + type: "object", 3357 3372 properties: { 3358 3373 id: { 3359 3359 - type: 'string', 3360 3360 - description: 'The unique identifier of the shout.', 3374 3374 + type: "string", 3375 3375 + description: "The unique identifier of the shout.", 3361 3376 }, 3362 3377 message: { 3363 3363 - type: 'string', 3364 3364 - description: 'The content of the shout.', 3378 3378 + type: "string", 3379 3379 + description: "The content of the shout.", 3365 3380 }, 3366 3381 parent: { 3367 3367 - type: 'string', 3382 3382 + type: "string", 3368 3383 description: 3369 3369 - 'The ID of the parent shout if this is a reply, otherwise null.', 3384 3384 + "The ID of the parent shout if this is a reply, otherwise null.", 3370 3385 }, 3371 3386 createdAt: { 3372 3372 - type: 'string', 3373 3373 - description: 'The date and time when the shout was created.', 3374 3374 - format: 'datetime', 3387 3387 + type: "string", 3388 3388 + description: "The date and time when the shout was created.", 3389 3389 + format: "datetime", 3375 3390 }, 3376 3391 author: { 3377 3377 - type: 'ref', 3378 3378 - description: 'The author of the shout.', 3379 3379 - ref: 'lex:app.rocksky.shout.defs#author', 3392 3392 + type: "ref", 3393 3393 + description: "The author of the shout.", 3394 3394 + ref: "lex:app.rocksky.shout.defs#author", 3380 3395 }, 3381 3396 }, 3382 3397 }, ··· 3384 3399 }, 3385 3400 AppRockskyShoutGetAlbumShouts: { 3386 3401 lexicon: 1, 3387 3387 - id: 'app.rocksky.shout.getAlbumShouts', 3402 3402 + id: "app.rocksky.shout.getAlbumShouts", 3388 3403 defs: { 3389 3404 main: { 3390 3390 - type: 'query', 3391 3391 - description: 'Get shouts for an album', 3405 3405 + type: "query", 3406 3406 + description: "Get shouts for an album", 3392 3407 parameters: { 3393 3393 - type: 'params', 3394 3394 - required: ['uri'], 3408 3408 + type: "params", 3409 3409 + required: ["uri"], 3395 3410 properties: { 3396 3411 uri: { 3397 3397 - type: 'string', 3412 3412 + type: "string", 3398 3413 description: 3399 3399 - 'The unique identifier of the album to retrieve shouts for', 3400 3400 - format: 'at-uri', 3414 3414 + "The unique identifier of the album to retrieve shouts for", 3415 3415 + format: "at-uri", 3401 3416 }, 3402 3417 limit: { 3403 3403 - type: 'integer', 3404 3404 - description: 'The maximum number of shouts to return', 3418 3418 + type: "integer", 3419 3419 + description: "The maximum number of shouts to return", 3405 3420 minimum: 1, 3406 3421 }, 3407 3422 offset: { 3408 3408 - type: 'integer', 3423 3423 + type: "integer", 3409 3424 description: 3410 3410 - 'The number of shouts to skip before starting to collect the result set', 3425 3425 + "The number of shouts to skip before starting to collect the result set", 3411 3426 minimum: 0, 3412 3427 }, 3413 3428 }, 3414 3429 }, 3415 3430 output: { 3416 3416 - encoding: 'application/json', 3431 3431 + encoding: "application/json", 3417 3432 schema: { 3418 3418 - type: 'object', 3433 3433 + type: "object", 3419 3434 properties: { 3420 3435 shouts: { 3421 3421 - type: 'array', 3436 3436 + type: "array", 3422 3437 items: { 3423 3423 - type: 'ref', 3424 3424 - ref: 'lex:app.rocksky.shout.defs#shoutViewBasic', 3438 3438 + type: "ref", 3439 3439 + ref: "lex:app.rocksky.shout.defs#shoutViewBasic", 3425 3440 }, 3426 3441 }, 3427 3442 }, ··· 3432 3447 }, 3433 3448 AppRockskyShoutGetArtistShouts: { 3434 3449 lexicon: 1, 3435 3435 - id: 'app.rocksky.shout.getArtistShouts', 3450 3450 + id: "app.rocksky.shout.getArtistShouts", 3436 3451 defs: { 3437 3452 main: { 3438 3438 - type: 'query', 3439 3439 - description: 'Get shouts for an artist', 3453 3453 + type: "query", 3454 3454 + description: "Get shouts for an artist", 3440 3455 parameters: { 3441 3441 - type: 'params', 3442 3442 - required: ['uri'], 3456 3456 + type: "params", 3457 3457 + required: ["uri"], 3443 3458 properties: { 3444 3459 uri: { 3445 3445 - type: 'string', 3446 3446 - description: 'The URI of the artist to retrieve shouts for', 3447 3447 - format: 'at-uri', 3460 3460 + type: "string", 3461 3461 + description: "The URI of the artist to retrieve shouts for", 3462 3462 + format: "at-uri", 3448 3463 }, 3449 3464 limit: { 3450 3450 - type: 'integer', 3451 3451 - description: 'The maximum number of shouts to return', 3465 3465 + type: "integer", 3466 3466 + description: "The maximum number of shouts to return", 3452 3467 minimum: 1, 3453 3468 }, 3454 3469 offset: { 3455 3455 - type: 'integer', 3470 3470 + type: "integer", 3456 3471 description: 3457 3457 - 'The number of shouts to skip before starting to collect the result set', 3472 3472 + "The number of shouts to skip before starting to collect the result set", 3458 3473 minimum: 0, 3459 3474 }, 3460 3475 }, 3461 3476 }, 3462 3477 output: { 3463 3463 - encoding: 'application/json', 3478 3478 + encoding: "application/json", 3464 3479 schema: { 3465 3465 - type: 'object', 3480 3480 + type: "object", 3466 3481 properties: { 3467 3482 shouts: { 3468 3468 - type: 'array', 3483 3483 + type: "array", 3469 3484 items: { 3470 3470 - type: 'ref', 3471 3471 - ref: 'lex:app.rocksky.shout.defs#shoutViewBasic', 3485 3485 + type: "ref", 3486 3486 + ref: "lex:app.rocksky.shout.defs#shoutViewBasic", 3472 3487 }, 3473 3488 }, 3474 3489 }, ··· 3479 3494 }, 3480 3495 AppRockskyShoutGetProfileShouts: { 3481 3496 lexicon: 1, 3482 3482 - id: 'app.rocksky.shout.getProfileShouts', 3497 3497 + id: "app.rocksky.shout.getProfileShouts", 3483 3498 defs: { 3484 3499 main: { 3485 3485 - type: 'query', 3500 3500 + type: "query", 3486 3501 description: "Get the shouts of an actor's profile", 3487 3502 parameters: { 3488 3488 - type: 'params', 3489 3489 - required: ['did'], 3503 3503 + type: "params", 3504 3504 + required: ["did"], 3490 3505 properties: { 3491 3506 did: { 3492 3492 - type: 'string', 3493 3493 - description: 'The DID or handle of the actor', 3494 3494 - format: 'at-identifier', 3507 3507 + type: "string", 3508 3508 + description: "The DID or handle of the actor", 3509 3509 + format: "at-identifier", 3495 3510 }, 3496 3511 offset: { 3497 3497 - type: 'integer', 3498 3498 - description: 'The offset for pagination', 3512 3512 + type: "integer", 3513 3513 + description: "The offset for pagination", 3499 3514 minimum: 0, 3500 3515 }, 3501 3516 limit: { 3502 3502 - type: 'integer', 3503 3503 - description: 'The maximum number of shouts to return', 3517 3517 + type: "integer", 3518 3518 + description: "The maximum number of shouts to return", 3504 3519 minimum: 1, 3505 3520 }, 3506 3521 }, 3507 3522 }, 3508 3523 output: { 3509 3509 - encoding: 'application/json', 3524 3524 + encoding: "application/json", 3510 3525 schema: { 3511 3511 - type: 'object', 3526 3526 + type: "object", 3512 3527 properties: { 3513 3528 shouts: { 3514 3514 - type: 'array', 3529 3529 + type: "array", 3515 3530 items: { 3516 3516 - type: 'ref', 3517 3517 - ref: 'lex:app.rocksky.shout.defs#shoutViewBasic', 3531 3531 + type: "ref", 3532 3532 + ref: "lex:app.rocksky.shout.defs#shoutViewBasic", 3518 3533 }, 3519 3534 }, 3520 3535 }, ··· 3525 3540 }, 3526 3541 AppRockskyShoutGetShoutReplies: { 3527 3542 lexicon: 1, 3528 3528 - id: 'app.rocksky.shout.getShoutReplies', 3543 3543 + id: "app.rocksky.shout.getShoutReplies", 3529 3544 defs: { 3530 3545 main: { 3531 3531 - type: 'query', 3532 3532 - description: 'Get replies to a shout', 3546 3546 + type: "query", 3547 3547 + description: "Get replies to a shout", 3533 3548 parameters: { 3534 3534 - type: 'params', 3535 3535 - required: ['uri'], 3549 3549 + type: "params", 3550 3550 + required: ["uri"], 3536 3551 properties: { 3537 3552 uri: { 3538 3538 - type: 'string', 3539 3539 - description: 'The URI of the shout to retrieve replies for', 3540 3540 - format: 'at-uri', 3553 3553 + type: "string", 3554 3554 + description: "The URI of the shout to retrieve replies for", 3555 3555 + format: "at-uri", 3541 3556 }, 3542 3557 limit: { 3543 3543 - type: 'integer', 3544 3544 - description: 'The maximum number of shouts to return', 3558 3558 + type: "integer", 3559 3559 + description: "The maximum number of shouts to return", 3545 3560 minimum: 1, 3546 3561 }, 3547 3562 offset: { 3548 3548 - type: 'integer', 3563 3563 + type: "integer", 3549 3564 description: 3550 3550 - 'The number of shouts to skip before starting to collect the result set', 3565 3565 + "The number of shouts to skip before starting to collect the result set", 3551 3566 minimum: 0, 3552 3567 }, 3553 3568 }, 3554 3569 }, 3555 3570 output: { 3556 3556 - encoding: 'application/json', 3571 3571 + encoding: "application/json", 3557 3572 schema: { 3558 3558 - type: 'object', 3573 3573 + type: "object", 3559 3574 properties: { 3560 3575 shouts: { 3561 3561 - type: 'array', 3576 3576 + type: "array", 3562 3577 items: { 3563 3563 - type: 'ref', 3564 3564 - ref: 'lex:app.rocksky.shout.defs#shoutViewBasic', 3578 3578 + type: "ref", 3579 3579 + ref: "lex:app.rocksky.shout.defs#shoutViewBasic", 3565 3580 }, 3566 3581 }, 3567 3582 }, ··· 3572 3587 }, 3573 3588 AppRockskyShoutGetTrackShouts: { 3574 3589 lexicon: 1, 3575 3575 - id: 'app.rocksky.shout.getTrackShouts', 3590 3590 + id: "app.rocksky.shout.getTrackShouts", 3576 3591 defs: { 3577 3592 main: { 3578 3578 - type: 'query', 3579 3579 - description: 'Get all shouts for a specific track', 3593 3593 + type: "query", 3594 3594 + description: "Get all shouts for a specific track", 3580 3595 parameters: { 3581 3581 - type: 'params', 3582 3582 - required: ['uri'], 3596 3596 + type: "params", 3597 3597 + required: ["uri"], 3583 3598 properties: { 3584 3599 uri: { 3585 3585 - type: 'string', 3586 3586 - description: 'The URI of the track to retrieve shouts for', 3587 3587 - format: 'at-uri', 3600 3600 + type: "string", 3601 3601 + description: "The URI of the track to retrieve shouts for", 3602 3602 + format: "at-uri", 3588 3603 }, 3589 3604 }, 3590 3605 }, 3591 3606 output: { 3592 3592 - encoding: 'application/json', 3607 3607 + encoding: "application/json", 3593 3608 schema: { 3594 3594 - type: 'object', 3609 3609 + type: "object", 3595 3610 properties: { 3596 3611 shouts: { 3597 3597 - type: 'array', 3612 3612 + type: "array", 3598 3613 items: { 3599 3599 - type: 'ref', 3600 3600 - ref: 'lex:app.rocksky.shout.defs#shoutViewBasic', 3614 3614 + type: "ref", 3615 3615 + ref: "lex:app.rocksky.shout.defs#shoutViewBasic", 3601 3616 }, 3602 3617 }, 3603 3618 }, ··· 3608 3623 }, 3609 3624 AppRockskyShoutRemoveShout: { 3610 3625 lexicon: 1, 3611 3611 - id: 'app.rocksky.shout.removeShout', 3626 3626 + id: "app.rocksky.shout.removeShout", 3612 3627 defs: { 3613 3628 main: { 3614 3614 - type: 'procedure', 3615 3615 - description: 'Remove a shout by its ID', 3629 3629 + type: "procedure", 3630 3630 + description: "Remove a shout by its ID", 3616 3631 parameters: { 3617 3617 - type: 'params', 3618 3618 - required: ['id'], 3632 3632 + type: "params", 3633 3633 + required: ["id"], 3619 3634 properties: { 3620 3635 id: { 3621 3621 - type: 'string', 3622 3622 - description: 'The ID of the shout to be removed', 3636 3636 + type: "string", 3637 3637 + description: "The ID of the shout to be removed", 3623 3638 }, 3624 3639 }, 3625 3640 }, 3626 3641 output: { 3627 3627 - encoding: 'application/json', 3642 3642 + encoding: "application/json", 3628 3643 schema: { 3629 3629 - type: 'ref', 3630 3630 - ref: 'lex:app.rocksky.shout.defs#shoutView', 3644 3644 + type: "ref", 3645 3645 + ref: "lex:app.rocksky.shout.defs#shoutView", 3631 3646 }, 3632 3647 }, 3633 3648 }, ··· 3635 3650 }, 3636 3651 AppRockskyShoutReplyShout: { 3637 3652 lexicon: 1, 3638 3638 - id: 'app.rocksky.shout.replyShout', 3653 3653 + id: "app.rocksky.shout.replyShout", 3639 3654 defs: { 3640 3655 main: { 3641 3641 - type: 'procedure', 3642 3642 - description: 'Reply to a shout', 3656 3656 + type: "procedure", 3657 3657 + description: "Reply to a shout", 3643 3658 input: { 3644 3644 - encoding: 'application/json', 3659 3659 + encoding: "application/json", 3645 3660 schema: { 3646 3646 - type: 'object', 3647 3647 - required: ['shoutId', 'message'], 3661 3661 + type: "object", 3662 3662 + required: ["shoutId", "message"], 3648 3663 properties: { 3649 3664 shoutId: { 3650 3650 - type: 'string', 3651 3651 - description: 'The unique identifier of the shout to reply to', 3665 3665 + type: "string", 3666 3666 + description: "The unique identifier of the shout to reply to", 3652 3667 }, 3653 3668 message: { 3654 3654 - type: 'string', 3655 3655 - description: 'The content of the reply', 3669 3669 + type: "string", 3670 3670 + description: "The content of the reply", 3656 3671 minLength: 1, 3657 3672 }, 3658 3673 }, 3659 3674 }, 3660 3675 }, 3661 3676 output: { 3662 3662 - encoding: 'application/json', 3677 3677 + encoding: "application/json", 3663 3678 schema: { 3664 3664 - type: 'ref', 3665 3665 - ref: 'lex:app.rocksky.shout.defs#shoutView', 3679 3679 + type: "ref", 3680 3680 + ref: "lex:app.rocksky.shout.defs#shoutView", 3666 3681 }, 3667 3682 }, 3668 3683 }, ··· 3670 3685 }, 3671 3686 AppRockskyShoutReportShout: { 3672 3687 lexicon: 1, 3673 3673 - id: 'app.rocksky.shout.reportShout', 3688 3688 + id: "app.rocksky.shout.reportShout", 3674 3689 defs: { 3675 3690 main: { 3676 3676 - type: 'procedure', 3677 3677 - description: 'Report a shout for moderation', 3691 3691 + type: "procedure", 3692 3692 + description: "Report a shout for moderation", 3678 3693 input: { 3679 3679 - encoding: 'application/json', 3694 3694 + encoding: "application/json", 3680 3695 schema: { 3681 3681 - type: 'object', 3682 3682 - required: ['shoutId'], 3696 3696 + type: "object", 3697 3697 + required: ["shoutId"], 3683 3698 properties: { 3684 3699 shoutId: { 3685 3685 - type: 'string', 3686 3686 - description: 'The unique identifier of the shout to report', 3700 3700 + type: "string", 3701 3701 + description: "The unique identifier of the shout to report", 3687 3702 }, 3688 3703 reason: { 3689 3689 - type: 'string', 3690 3690 - description: 'The reason for reporting the shout', 3704 3704 + type: "string", 3705 3705 + description: "The reason for reporting the shout", 3691 3706 minLength: 1, 3692 3707 }, 3693 3708 }, 3694 3709 }, 3695 3710 }, 3696 3711 output: { 3697 3697 - encoding: 'application/json', 3712 3712 + encoding: "application/json", 3698 3713 schema: { 3699 3699 - type: 'ref', 3700 3700 - ref: 'lex:app.rocksky.shout.defs#shoutView', 3714 3714 + type: "ref", 3715 3715 + ref: "lex:app.rocksky.shout.defs#shoutView", 3701 3716 }, 3702 3717 }, 3703 3718 }, ··· 3705 3720 }, 3706 3721 AppRockskyShout: { 3707 3722 lexicon: 1, 3708 3708 - id: 'app.rocksky.shout', 3723 3723 + id: "app.rocksky.shout", 3709 3724 defs: { 3710 3725 main: { 3711 3711 - type: 'record', 3712 3712 - description: 'A declaration of a shout.', 3713 3713 - key: 'tid', 3726 3726 + type: "record", 3727 3727 + description: "A declaration of a shout.", 3728 3728 + key: "tid", 3714 3729 record: { 3715 3715 - type: 'object', 3716 3716 - required: ['message', 'createdAt', 'subject'], 3730 3730 + type: "object", 3731 3731 + required: ["message", "createdAt", "subject"], 3717 3732 properties: { 3718 3733 message: { 3719 3719 - type: 'string', 3720 3720 - description: 'The message of the shout.', 3734 3734 + type: "string", 3735 3735 + description: "The message of the shout.", 3721 3736 minLength: 1, 3722 3737 maxLength: 1000, 3723 3738 }, 3724 3739 createdAt: { 3725 3725 - type: 'string', 3726 3726 - description: 'The date when the shout was created.', 3727 3727 - format: 'datetime', 3740 3740 + type: "string", 3741 3741 + description: "The date when the shout was created.", 3742 3742 + format: "datetime", 3728 3743 }, 3729 3744 parent: { 3730 3730 - type: 'ref', 3731 3731 - ref: 'lex:com.atproto.repo.strongRef', 3745 3745 + type: "ref", 3746 3746 + ref: "lex:com.atproto.repo.strongRef", 3732 3747 }, 3733 3748 subject: { 3734 3734 - type: 'ref', 3735 3735 - ref: 'lex:com.atproto.repo.strongRef', 3749 3749 + type: "ref", 3750 3750 + ref: "lex:com.atproto.repo.strongRef", 3736 3751 }, 3737 3752 }, 3738 3753 }, ··· 3741 3756 }, 3742 3757 AppRockskySongCreateSong: { 3743 3758 lexicon: 1, 3744 3744 - id: 'app.rocksky.song.createSong', 3759 3759 + id: "app.rocksky.song.createSong", 3745 3760 defs: { 3746 3761 main: { 3747 3747 - type: 'procedure', 3748 3748 - description: 'Create a new song', 3762 3762 + type: "procedure", 3763 3763 + description: "Create a new song", 3749 3764 input: { 3750 3750 - encoding: 'application/json', 3765 3765 + encoding: "application/json", 3751 3766 schema: { 3752 3752 - type: 'object', 3753 3753 - required: ['title', 'artist', 'album', 'albumArtist'], 3767 3767 + type: "object", 3768 3768 + required: ["title", "artist", "album", "albumArtist"], 3754 3769 properties: { 3755 3770 title: { 3756 3756 - type: 'string', 3757 3757 - description: 'The title of the song', 3771 3771 + type: "string", 3772 3772 + description: "The title of the song", 3758 3773 }, 3759 3774 artist: { 3760 3760 - type: 'string', 3761 3761 - description: 'The artist of the song', 3775 3775 + type: "string", 3776 3776 + description: "The artist of the song", 3762 3777 }, 3763 3778 albumArtist: { 3764 3764 - type: 'string', 3779 3779 + type: "string", 3765 3780 description: 3766 3766 - 'The album artist of the song, if different from the main artist', 3781 3781 + "The album artist of the song, if different from the main artist", 3767 3782 }, 3768 3783 album: { 3769 3769 - type: 'string', 3770 3770 - description: 'The album of the song, if applicable', 3784 3784 + type: "string", 3785 3785 + description: "The album of the song, if applicable", 3771 3786 }, 3772 3787 duration: { 3773 3773 - type: 'integer', 3774 3774 - description: 'The duration of the song in seconds', 3788 3788 + type: "integer", 3789 3789 + description: "The duration of the song in seconds", 3775 3790 }, 3776 3791 mbId: { 3777 3777 - type: 'string', 3778 3778 - description: 'The MusicBrainz ID of the song, if available', 3792 3792 + type: "string", 3793 3793 + description: "The MusicBrainz ID of the song, if available", 3779 3794 }, 3780 3795 albumArt: { 3781 3781 - type: 'string', 3782 3782 - description: 'The URL of the album art for the song', 3783 3783 - format: 'uri', 3796 3796 + type: "string", 3797 3797 + description: "The URL of the album art for the song", 3798 3798 + format: "uri", 3784 3799 }, 3785 3800 trackNumber: { 3786 3786 - type: 'integer', 3801 3801 + type: "integer", 3787 3802 description: 3788 3788 - 'The track number of the song in the album, if applicable', 3803 3803 + "The track number of the song in the album, if applicable", 3789 3804 }, 3790 3805 releaseDate: { 3791 3791 - type: 'string', 3806 3806 + type: "string", 3792 3807 description: 3793 3793 - 'The release date of the song, formatted as YYYY-MM-DD', 3808 3808 + "The release date of the song, formatted as YYYY-MM-DD", 3794 3809 }, 3795 3810 year: { 3796 3796 - type: 'integer', 3797 3797 - description: 'The year the song was released', 3811 3811 + type: "integer", 3812 3812 + description: "The year the song was released", 3798 3813 }, 3799 3814 discNumber: { 3800 3800 - type: 'integer', 3815 3815 + type: "integer", 3801 3816 description: 3802 3802 - 'The disc number of the song in the album, if applicable', 3817 3817 + "The disc number of the song in the album, if applicable", 3803 3818 }, 3804 3819 lyrics: { 3805 3805 - type: 'string', 3806 3806 - description: 'The lyrics of the song, if available', 3820 3820 + type: "string", 3821 3821 + description: "The lyrics of the song, if available", 3807 3822 }, 3808 3823 }, 3809 3824 }, 3810 3825 }, 3811 3826 output: { 3812 3812 - encoding: 'application/json', 3827 3827 + encoding: "application/json", 3813 3828 schema: { 3814 3814 - type: 'ref', 3815 3815 - ref: 'lex:app.rocksky.song.defs#songViewDetailed', 3829 3829 + type: "ref", 3830 3830 + ref: "lex:app.rocksky.song.defs#songViewDetailed", 3816 3831 }, 3817 3832 }, 3818 3833 }, ··· 3820 3835 }, 3821 3836 AppRockskySongDefs: { 3822 3837 lexicon: 1, 3823 3823 - id: 'app.rocksky.song.defs', 3838 3838 + id: "app.rocksky.song.defs", 3824 3839 defs: { 3825 3840 songViewBasic: { 3826 3826 - type: 'object', 3841 3841 + type: "object", 3827 3842 properties: { 3828 3843 id: { 3829 3829 - type: 'string', 3830 3830 - description: 'The unique identifier of the song.', 3844 3844 + type: "string", 3845 3845 + description: "The unique identifier of the song.", 3831 3846 }, 3832 3847 title: { 3833 3833 - type: 'string', 3834 3834 - description: 'The title of the song.', 3848 3848 + type: "string", 3849 3849 + description: "The title of the song.", 3835 3850 }, 3836 3851 artist: { 3837 3837 - type: 'string', 3838 3838 - description: 'The artist of the song.', 3852 3852 + type: "string", 3853 3853 + description: "The artist of the song.", 3839 3854 }, 3840 3855 albumArtist: { 3841 3841 - type: 'string', 3842 3842 - description: 'The artist of the album the song belongs to.', 3856 3856 + type: "string", 3857 3857 + description: "The artist of the album the song belongs to.", 3843 3858 }, 3844 3859 albumArt: { 3845 3845 - type: 'string', 3846 3846 - description: 'The URL of the album art image.', 3847 3847 - format: 'uri', 3860 3860 + type: "string", 3861 3861 + description: "The URL of the album art image.", 3862 3862 + format: "uri", 3848 3863 }, 3849 3864 uri: { 3850 3850 - type: 'string', 3851 3851 - description: 'The URI of the song.', 3852 3852 - format: 'at-uri', 3865 3865 + type: "string", 3866 3866 + description: "The URI of the song.", 3867 3867 + format: "at-uri", 3853 3868 }, 3854 3869 album: { 3855 3855 - type: 'string', 3856 3856 - description: 'The album of the song.', 3870 3870 + type: "string", 3871 3871 + description: "The album of the song.", 3857 3872 }, 3858 3873 duration: { 3859 3859 - type: 'integer', 3860 3860 - description: 'The duration of the song in milliseconds.', 3874 3874 + type: "integer", 3875 3875 + description: "The duration of the song in milliseconds.", 3861 3876 }, 3862 3877 trackNumber: { 3863 3863 - type: 'integer', 3864 3864 - description: 'The track number of the song in the album.', 3878 3878 + type: "integer", 3879 3879 + description: "The track number of the song in the album.", 3865 3880 }, 3866 3881 discNumber: { 3867 3867 - type: 'integer', 3868 3868 - description: 'The disc number of the song in the album.', 3882 3882 + type: "integer", 3883 3883 + description: "The disc number of the song in the album.", 3869 3884 }, 3870 3885 playCount: { 3871 3871 - type: 'integer', 3872 3872 - description: 'The number of times the song has been played.', 3886 3886 + type: "integer", 3887 3887 + description: "The number of times the song has been played.", 3873 3888 minimum: 0, 3874 3889 }, 3875 3890 uniqueListeners: { 3876 3876 - type: 'integer', 3891 3891 + type: "integer", 3877 3892 description: 3878 3878 - 'The number of unique listeners who have played the song.', 3893 3893 + "The number of unique listeners who have played the song.", 3879 3894 minimum: 0, 3880 3895 }, 3881 3896 albumUri: { 3882 3882 - type: 'string', 3883 3883 - description: 'The URI of the album the song belongs to.', 3884 3884 - format: 'at-uri', 3897 3897 + type: "string", 3898 3898 + description: "The URI of the album the song belongs to.", 3899 3899 + format: "at-uri", 3885 3900 }, 3886 3901 artistUri: { 3887 3887 - type: 'string', 3888 3888 - description: 'The URI of the artist of the song.', 3889 3889 - format: 'at-uri', 3902 3902 + type: "string", 3903 3903 + description: "The URI of the artist of the song.", 3904 3904 + format: "at-uri", 3890 3905 }, 3891 3906 sha256: { 3892 3892 - type: 'string', 3893 3893 - description: 'The SHA256 hash of the song.', 3907 3907 + type: "string", 3908 3908 + description: "The SHA256 hash of the song.", 3894 3909 }, 3895 3910 createdAt: { 3896 3896 - type: 'string', 3897 3897 - description: 'The timestamp when the song was created.', 3898 3898 - format: 'datetime', 3911 3911 + type: "string", 3912 3912 + description: "The timestamp when the song was created.", 3913 3913 + format: "datetime", 3899 3914 }, 3900 3915 }, 3901 3916 }, 3902 3917 songViewDetailed: { 3903 3903 - type: 'object', 3918 3918 + type: "object", 3904 3919 properties: { 3905 3920 id: { 3906 3906 - type: 'string', 3907 3907 - description: 'The unique identifier of the song.', 3921 3921 + type: "string", 3922 3922 + description: "The unique identifier of the song.", 3908 3923 }, 3909 3924 title: { 3910 3910 - type: 'string', 3911 3911 - description: 'The title of the song.', 3925 3925 + type: "string", 3926 3926 + description: "The title of the song.", 3912 3927 }, 3913 3928 artist: { 3914 3914 - type: 'string', 3915 3915 - description: 'The artist of the song.', 3929 3929 + type: "string", 3930 3930 + description: "The artist of the song.", 3916 3931 }, 3917 3932 albumArtist: { 3918 3918 - type: 'string', 3919 3919 - description: 'The artist of the album the song belongs to.', 3933 3933 + type: "string", 3934 3934 + description: "The artist of the album the song belongs to.", 3920 3935 }, 3921 3936 albumArt: { 3922 3922 - type: 'string', 3923 3923 - description: 'The URL of the album art image.', 3924 3924 - format: 'uri', 3937 3937 + type: "string", 3938 3938 + description: "The URL of the album art image.", 3939 3939 + format: "uri", 3925 3940 }, 3926 3941 uri: { 3927 3927 - type: 'string', 3928 3928 - description: 'The URI of the song.', 3929 3929 - format: 'at-uri', 3942 3942 + type: "string", 3943 3943 + description: "The URI of the song.", 3944 3944 + format: "at-uri", 3930 3945 }, 3931 3946 album: { 3932 3932 - type: 'string', 3933 3933 - description: 'The album of the song.', 3947 3947 + type: "string", 3948 3948 + description: "The album of the song.", 3934 3949 }, 3935 3950 duration: { 3936 3936 - type: 'integer', 3937 3937 - description: 'The duration of the song in milliseconds.', 3951 3951 + type: "integer", 3952 3952 + description: "The duration of the song in milliseconds.", 3938 3953 }, 3939 3954 trackNumber: { 3940 3940 - type: 'integer', 3941 3941 - description: 'The track number of the song in the album.', 3955 3955 + type: "integer", 3956 3956 + description: "The track number of the song in the album.", 3942 3957 }, 3943 3958 discNumber: { 3944 3944 - type: 'integer', 3945 3945 - description: 'The disc number of the song in the album.', 3959 3959 + type: "integer", 3960 3960 + description: "The disc number of the song in the album.", 3946 3961 }, 3947 3962 playCount: { 3948 3948 - type: 'integer', 3949 3949 - description: 'The number of times the song has been played.', 3963 3963 + type: "integer", 3964 3964 + description: "The number of times the song has been played.", 3950 3965 minimum: 0, 3951 3966 }, 3952 3967 uniqueListeners: { 3953 3953 - type: 'integer', 3968 3968 + type: "integer", 3954 3969 description: 3955 3955 - 'The number of unique listeners who have played the song.', 3970 3970 + "The number of unique listeners who have played the song.", 3956 3971 minimum: 0, 3957 3972 }, 3958 3973 albumUri: { 3959 3959 - type: 'string', 3960 3960 - description: 'The URI of the album the song belongs to.', 3961 3961 - format: 'at-uri', 3974 3974 + type: "string", 3975 3975 + description: "The URI of the album the song belongs to.", 3976 3976 + format: "at-uri", 3962 3977 }, 3963 3978 artistUri: { 3964 3964 - type: 'string', 3965 3965 - description: 'The URI of the artist of the song.', 3966 3966 - format: 'at-uri', 3979 3979 + type: "string", 3980 3980 + description: "The URI of the artist of the song.", 3981 3981 + format: "at-uri", 3967 3982 }, 3968 3983 sha256: { 3969 3969 - type: 'string', 3970 3970 - description: 'The SHA256 hash of the song.', 3984 3984 + type: "string", 3985 3985 + description: "The SHA256 hash of the song.", 3971 3986 }, 3972 3987 createdAt: { 3973 3973 - type: 'string', 3974 3974 - description: 'The timestamp when the song was created.', 3975 3975 - format: 'datetime', 3988 3988 + type: "string", 3989 3989 + description: "The timestamp when the song was created.", 3990 3990 + format: "datetime", 3976 3991 }, 3977 3992 }, 3978 3993 }, ··· 3980 3995 }, 3981 3996 AppRockskySongGetSong: { 3982 3997 lexicon: 1, 3983 3983 - id: 'app.rocksky.song.getSong', 3998 3998 + id: "app.rocksky.song.getSong", 3984 3999 defs: { 3985 4000 main: { 3986 3986 - type: 'query', 3987 3987 - description: 'Get a song by its uri', 4001 4001 + type: "query", 4002 4002 + description: "Get a song by its uri", 3988 4003 parameters: { 3989 3989 - type: 'params', 3990 3990 - required: ['uri'], 4004 4004 + type: "params", 4005 4005 + required: ["uri"], 3991 4006 properties: { 3992 4007 uri: { 3993 3993 - type: 'string', 3994 3994 - description: 'The unique identifier of the song to retrieve', 3995 3995 - format: 'at-uri', 4008 4008 + type: "string", 4009 4009 + description: "The unique identifier of the song to retrieve", 4010 4010 + format: "at-uri", 3996 4011 }, 3997 4012 }, 3998 4013 }, 3999 4014 output: { 4000 4000 - encoding: 'application/json', 4015 4015 + encoding: "application/json", 4001 4016 schema: { 4002 4002 - type: 'ref', 4003 4003 - ref: 'lex:app.rocksky.song.defs#songViewDetailed', 4017 4017 + type: "ref", 4018 4018 + ref: "lex:app.rocksky.song.defs#songViewDetailed", 4004 4019 }, 4005 4020 }, 4006 4021 }, ··· 4008 4023 }, 4009 4024 AppRockskySongGetSongs: { 4010 4025 lexicon: 1, 4011 4011 - id: 'app.rocksky.song.getSongs', 4026 4026 + id: "app.rocksky.song.getSongs", 4012 4027 defs: { 4013 4028 main: { 4014 4014 - type: 'query', 4015 4015 - description: 'Get songs', 4029 4029 + type: "query", 4030 4030 + description: "Get songs", 4016 4031 parameters: { 4017 4017 - type: 'params', 4032 4032 + type: "params", 4018 4033 properties: { 4019 4034 limit: { 4020 4020 - type: 'integer', 4021 4021 - description: 'The maximum number of songs to return', 4035 4035 + type: "integer", 4036 4036 + description: "The maximum number of songs to return", 4022 4037 minimum: 1, 4023 4038 }, 4024 4039 offset: { 4025 4025 - type: 'integer', 4026 4026 - description: 'The offset for pagination', 4040 4040 + type: "integer", 4041 4041 + description: "The offset for pagination", 4027 4042 minimum: 0, 4028 4043 }, 4029 4044 }, 4030 4045 }, 4031 4046 output: { 4032 4032 - encoding: 'application/json', 4047 4047 + encoding: "application/json", 4033 4048 schema: { 4034 4034 - type: 'object', 4049 4049 + type: "object", 4035 4050 properties: { 4036 4051 songs: { 4037 4037 - type: 'array', 4052 4052 + type: "array", 4038 4053 items: { 4039 4039 - type: 'ref', 4040 4040 - ref: 'lex:app.rocksky.song.defs#songViewBasic', 4054 4054 + type: "ref", 4055 4055 + ref: "lex:app.rocksky.song.defs#songViewBasic", 4041 4056 }, 4042 4057 }, 4043 4058 }, ··· 4048 4063 }, 4049 4064 AppRockskySong: { 4050 4065 lexicon: 1, 4051 4051 - id: 'app.rocksky.song', 4066 4066 + id: "app.rocksky.song", 4052 4067 defs: { 4053 4068 main: { 4054 4054 - type: 'record', 4055 4055 - description: 'A declaration of a song.', 4056 4056 - key: 'tid', 4069 4069 + type: "record", 4070 4070 + description: "A declaration of a song.", 4071 4071 + key: "tid", 4057 4072 record: { 4058 4058 - type: 'object', 4073 4073 + type: "object", 4059 4074 required: [ 4060 4060 - 'title', 4061 4061 - 'artist', 4062 4062 - 'album', 4063 4063 - 'albumArtist', 4064 4064 - 'duration', 4065 4065 - 'createdAt', 4075 4075 + "title", 4076 4076 + "artist", 4077 4077 + "album", 4078 4078 + "albumArtist", 4079 4079 + "duration", 4080 4080 + "createdAt", 4066 4081 ], 4067 4082 properties: { 4068 4083 title: { 4069 4069 - type: 'string', 4070 4070 - description: 'The title of the song.', 4084 4084 + type: "string", 4085 4085 + description: "The title of the song.", 4071 4086 minLength: 1, 4072 4087 maxLength: 512, 4073 4088 }, 4074 4089 artist: { 4075 4075 - type: 'string', 4076 4076 - description: 'The artist of the song.', 4090 4090 + type: "string", 4091 4091 + description: "The artist of the song.", 4077 4092 minLength: 1, 4078 4093 maxLength: 256, 4079 4094 }, 4080 4095 albumArtist: { 4081 4081 - type: 'string', 4082 4082 - description: 'The album artist of the song.', 4096 4096 + type: "string", 4097 4097 + description: "The album artist of the song.", 4083 4098 minLength: 1, 4084 4099 maxLength: 256, 4085 4100 }, 4086 4101 album: { 4087 4087 - type: 'string', 4088 4088 - description: 'The album of the song.', 4102 4102 + type: "string", 4103 4103 + description: "The album of the song.", 4089 4104 minLength: 1, 4090 4105 maxLength: 256, 4091 4106 }, 4092 4107 duration: { 4093 4093 - type: 'integer', 4094 4094 - description: 'The duration of the song in seconds.', 4108 4108 + type: "integer", 4109 4109 + description: "The duration of the song in seconds.", 4095 4110 minimum: 1, 4096 4111 }, 4097 4112 trackNumber: { 4098 4098 - type: 'integer', 4099 4099 - description: 'The track number of the song in the album.', 4113 4113 + type: "integer", 4114 4114 + description: "The track number of the song in the album.", 4100 4115 minimum: 1, 4101 4116 }, 4102 4117 discNumber: { 4103 4103 - type: 'integer', 4104 4104 - description: 'The disc number of the song in the album.', 4118 4118 + type: "integer", 4119 4119 + description: "The disc number of the song in the album.", 4105 4120 minimum: 1, 4106 4121 }, 4107 4122 releaseDate: { 4108 4108 - type: 'string', 4109 4109 - description: 'The release date of the song.', 4110 4110 - format: 'datetime', 4123 4123 + type: "string", 4124 4124 + description: "The release date of the song.", 4125 4125 + format: "datetime", 4111 4126 }, 4112 4127 year: { 4113 4113 - type: 'integer', 4114 4114 - description: 'The year the song was released.', 4128 4128 + type: "integer", 4129 4129 + description: "The year the song was released.", 4115 4130 }, 4116 4131 genre: { 4117 4117 - type: 'string', 4118 4118 - description: 'The genre of the song.', 4132 4132 + type: "string", 4133 4133 + description: "The genre of the song.", 4119 4134 minLength: 1, 4120 4135 maxLength: 256, 4121 4136 }, 4122 4137 tags: { 4123 4123 - type: 'array', 4124 4124 - description: 'The tags of the song.', 4138 4138 + type: "array", 4139 4139 + description: "The tags of the song.", 4125 4140 items: { 4126 4126 - type: 'string', 4141 4141 + type: "string", 4127 4142 minLength: 1, 4128 4143 maxLength: 256, 4129 4144 }, 4130 4145 }, 4131 4146 composer: { 4132 4132 - type: 'string', 4133 4133 - description: 'The composer of the song.', 4147 4147 + type: "string", 4148 4148 + description: "The composer of the song.", 4134 4149 maxLength: 256, 4135 4150 }, 4136 4151 lyrics: { 4137 4137 - type: 'string', 4138 4138 - description: 'The lyrics of the song.', 4152 4152 + type: "string", 4153 4153 + description: "The lyrics of the song.", 4139 4154 maxLength: 10000, 4140 4155 }, 4141 4156 copyrightMessage: { 4142 4142 - type: 'string', 4143 4143 - description: 'The copyright message of the song.', 4157 4157 + type: "string", 4158 4158 + description: "The copyright message of the song.", 4144 4159 maxLength: 256, 4145 4160 }, 4146 4161 wiki: { 4147 4147 - type: 'string', 4148 4148 - description: 'Informations about the song', 4162 4162 + type: "string", 4163 4163 + description: "Informations about the song", 4149 4164 maxLength: 10000, 4150 4165 }, 4151 4166 albumArt: { 4152 4152 - type: 'blob', 4153 4153 - description: 'The album art of the song.', 4154 4154 - accept: ['image/png', 'image/jpeg'], 4167 4167 + type: "blob", 4168 4168 + description: "The album art of the song.", 4169 4169 + accept: ["image/png", "image/jpeg"], 4155 4170 maxSize: 2000000, 4156 4171 }, 4172 4172 + albumArtUrl: { 4173 4173 + type: "string", 4174 4174 + description: "The URL of the album art of the song.", 4175 4175 + format: "uri", 4176 4176 + }, 4157 4177 youtubeLink: { 4158 4158 - type: 'string', 4159 4159 - description: 'The YouTube link of the song.', 4160 4160 - format: 'uri', 4178 4178 + type: "string", 4179 4179 + description: "The YouTube link of the song.", 4180 4180 + format: "uri", 4161 4181 }, 4162 4182 spotifyLink: { 4163 4163 - type: 'string', 4164 4164 - description: 'The Spotify link of the song.', 4165 4165 - format: 'uri', 4183 4183 + type: "string", 4184 4184 + description: "The Spotify link of the song.", 4185 4185 + format: "uri", 4166 4186 }, 4167 4187 tidalLink: { 4168 4168 - type: 'string', 4169 4169 - description: 'The Tidal link of the song.', 4170 4170 - format: 'uri', 4188 4188 + type: "string", 4189 4189 + description: "The Tidal link of the song.", 4190 4190 + format: "uri", 4171 4191 }, 4172 4192 appleMusicLink: { 4173 4173 - type: 'string', 4174 4174 - description: 'The Apple Music link of the song.', 4175 4175 - format: 'uri', 4193 4193 + type: "string", 4194 4194 + description: "The Apple Music link of the song.", 4195 4195 + format: "uri", 4176 4196 }, 4177 4197 createdAt: { 4178 4178 - type: 'string', 4179 4179 - description: 'The date when the song was created.', 4180 4180 - format: 'datetime', 4198 4198 + type: "string", 4199 4199 + description: "The date when the song was created.", 4200 4200 + format: "datetime", 4181 4201 }, 4182 4202 mbid: { 4183 4183 - type: 'string', 4184 4184 - description: 'The MusicBrainz ID of the song.', 4203 4203 + type: "string", 4204 4204 + description: "The MusicBrainz ID of the song.", 4185 4205 }, 4186 4206 label: { 4187 4187 - type: 'string', 4188 4188 - description: 'The label of the song.', 4207 4207 + type: "string", 4208 4208 + description: "The label of the song.", 4189 4209 maxLength: 256, 4190 4210 }, 4191 4211 }, ··· 4195 4215 }, 4196 4216 AppRockskySpotifyDefs: { 4197 4217 lexicon: 1, 4198 4198 - id: 'app.rocksky.spotify.defs', 4218 4218 + id: "app.rocksky.spotify.defs", 4199 4219 defs: { 4200 4220 spotifyTrackView: { 4201 4201 - type: 'object', 4221 4221 + type: "object", 4202 4222 properties: { 4203 4223 id: { 4204 4204 - type: 'string', 4205 4205 - description: 'The unique identifier of the Spotify track.', 4224 4224 + type: "string", 4225 4225 + description: "The unique identifier of the Spotify track.", 4206 4226 }, 4207 4227 name: { 4208 4208 - type: 'string', 4209 4209 - description: 'The name of the track.', 4228 4228 + type: "string", 4229 4229 + description: "The name of the track.", 4210 4230 }, 4211 4231 artist: { 4212 4212 - type: 'string', 4213 4213 - description: 'The name of the artist.', 4232 4232 + type: "string", 4233 4233 + description: "The name of the artist.", 4214 4234 }, 4215 4235 album: { 4216 4216 - type: 'string', 4217 4217 - description: 'The name of the album.', 4236 4236 + type: "string", 4237 4237 + description: "The name of the album.", 4218 4238 }, 4219 4239 duration: { 4220 4220 - type: 'integer', 4221 4221 - description: 'The duration of the track in milliseconds.', 4240 4240 + type: "integer", 4241 4241 + description: "The duration of the track in milliseconds.", 4222 4242 }, 4223 4243 previewUrl: { 4224 4224 - type: 'string', 4225 4225 - description: 'A URL to a preview of the track.', 4244 4244 + type: "string", 4245 4245 + description: "A URL to a preview of the track.", 4226 4246 }, 4227 4247 }, 4228 4248 }, ··· 4230 4250 }, 4231 4251 AppRockskySpotifyGetCurrentlyPlaying: { 4232 4252 lexicon: 1, 4233 4233 - id: 'app.rocksky.spotify.getCurrentlyPlaying', 4253 4253 + id: "app.rocksky.spotify.getCurrentlyPlaying", 4234 4254 defs: { 4235 4255 main: { 4236 4236 - type: 'query', 4237 4237 - description: 'Get the currently playing track', 4256 4256 + type: "query", 4257 4257 + description: "Get the currently playing track", 4238 4258 parameters: { 4239 4239 - type: 'params', 4259 4259 + type: "params", 4240 4260 properties: { 4241 4261 actor: { 4242 4242 - type: 'string', 4262 4262 + type: "string", 4243 4263 description: 4244 4244 - 'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.', 4245 4245 - format: 'at-identifier', 4264 4264 + "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.", 4265 4265 + format: "at-identifier", 4246 4266 }, 4247 4267 }, 4248 4268 }, 4249 4269 output: { 4250 4250 - encoding: 'application/json', 4270 4270 + encoding: "application/json", 4251 4271 schema: { 4252 4252 - type: 'ref', 4253 4253 - ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed', 4272 4272 + type: "ref", 4273 4273 + ref: "lex:app.rocksky.player.defs#currentlyPlayingViewDetailed", 4254 4274 }, 4255 4275 }, 4256 4276 }, ··· 4258 4278 }, 4259 4279 AppRockskySpotifyNext: { 4260 4280 lexicon: 1, 4261 4261 - id: 'app.rocksky.spotify.next', 4281 4281 + id: "app.rocksky.spotify.next", 4262 4282 defs: { 4263 4283 main: { 4264 4264 - type: 'procedure', 4265 4265 - description: 'Play the next track in the queue', 4284 4284 + type: "procedure", 4285 4285 + description: "Play the next track in the queue", 4266 4286 }, 4267 4287 }, 4268 4288 }, 4269 4289 AppRockskySpotifyPause: { 4270 4290 lexicon: 1, 4271 4271 - id: 'app.rocksky.spotify.pause', 4291 4291 + id: "app.rocksky.spotify.pause", 4272 4292 defs: { 4273 4293 main: { 4274 4274 - type: 'procedure', 4275 4275 - description: 'Pause the currently playing track', 4294 4294 + type: "procedure", 4295 4295 + description: "Pause the currently playing track", 4276 4296 }, 4277 4297 }, 4278 4298 }, 4279 4299 AppRockskySpotifyPlay: { 4280 4300 lexicon: 1, 4281 4281 - id: 'app.rocksky.spotify.play', 4301 4301 + id: "app.rocksky.spotify.play", 4282 4302 defs: { 4283 4303 main: { 4284 4284 - type: 'procedure', 4285 4285 - description: 'Resume playback of the currently paused track', 4304 4304 + type: "procedure", 4305 4305 + description: "Resume playback of the currently paused track", 4286 4306 }, 4287 4307 }, 4288 4308 }, 4289 4309 AppRockskySpotifyPrevious: { 4290 4310 lexicon: 1, 4291 4291 - id: 'app.rocksky.spotify.previous', 4311 4311 + id: "app.rocksky.spotify.previous", 4292 4312 defs: { 4293 4313 main: { 4294 4294 - type: 'procedure', 4295 4295 - description: 'Play the previous track in the queue', 4314 4314 + type: "procedure", 4315 4315 + description: "Play the previous track in the queue", 4296 4316 }, 4297 4317 }, 4298 4318 }, 4299 4319 AppRockskySpotifySeek: { 4300 4320 lexicon: 1, 4301 4301 - id: 'app.rocksky.spotify.seek', 4321 4321 + id: "app.rocksky.spotify.seek", 4302 4322 defs: { 4303 4323 main: { 4304 4304 - type: 'procedure', 4324 4324 + type: "procedure", 4305 4325 description: 4306 4306 - 'Seek to a specific position in the currently playing track', 4326 4326 + "Seek to a specific position in the currently playing track", 4307 4327 parameters: { 4308 4308 - type: 'params', 4309 4309 - required: ['position'], 4328 4328 + type: "params", 4329 4329 + required: ["position"], 4310 4330 properties: { 4311 4331 position: { 4312 4312 - type: 'integer', 4313 4313 - description: 'The position in seconds to seek to', 4332 4332 + type: "integer", 4333 4333 + description: "The position in seconds to seek to", 4314 4334 }, 4315 4335 }, 4316 4336 }, ··· 4319 4339 }, 4320 4340 AppRockskyStatsDefs: { 4321 4341 lexicon: 1, 4322 4322 - id: 'app.rocksky.stats.defs', 4342 4342 + id: "app.rocksky.stats.defs", 4323 4343 defs: { 4324 4344 statsView: { 4325 4325 - type: 'object', 4345 4345 + type: "object", 4326 4346 properties: { 4327 4347 scrobbles: { 4328 4328 - type: 'integer', 4329 4329 - description: 'The total number of scrobbles.', 4348 4348 + type: "integer", 4349 4349 + description: "The total number of scrobbles.", 4330 4350 }, 4331 4351 artists: { 4332 4332 - type: 'integer', 4333 4333 - description: 'The total number of unique artists scrobbled.', 4352 4352 + type: "integer", 4353 4353 + description: "The total number of unique artists scrobbled.", 4334 4354 }, 4335 4355 lovedTracks: { 4336 4336 - type: 'integer', 4337 4337 - description: 'The total number of tracks marked as loved.', 4356 4356 + type: "integer", 4357 4357 + description: "The total number of tracks marked as loved.", 4338 4358 }, 4339 4359 albums: { 4340 4340 - type: 'integer', 4341 4341 - description: 'The total number of unique albums scrobbled.', 4360 4360 + type: "integer", 4361 4361 + description: "The total number of unique albums scrobbled.", 4342 4362 }, 4343 4363 tracks: { 4344 4344 - type: 'integer', 4345 4345 - description: 'The total number of unique tracks scrobbled.', 4364 4364 + type: "integer", 4365 4365 + description: "The total number of unique tracks scrobbled.", 4346 4366 }, 4347 4367 }, 4348 4368 }, ··· 4350 4370 }, 4351 4371 AppRockskyStatsGetStats: { 4352 4372 lexicon: 1, 4353 4353 - id: 'app.rocksky.stats.getStats', 4373 4373 + id: "app.rocksky.stats.getStats", 4354 4374 defs: { 4355 4375 main: { 4356 4356 - type: 'query', 4376 4376 + type: "query", 4357 4377 parameters: { 4358 4358 - type: 'params', 4359 4359 - required: ['did'], 4378 4378 + type: "params", 4379 4379 + required: ["did"], 4360 4380 properties: { 4361 4381 did: { 4362 4362 - type: 'string', 4363 4363 - description: 'The DID or handle of the user to get stats for.', 4364 4364 - format: 'at-identifier', 4382 4382 + type: "string", 4383 4383 + description: "The DID or handle of the user to get stats for.", 4384 4384 + format: "at-identifier", 4365 4385 }, 4366 4386 }, 4367 4387 }, 4368 4388 output: { 4369 4369 - encoding: 'application/json', 4389 4389 + encoding: "application/json", 4370 4390 schema: { 4371 4371 - type: 'ref', 4372 4372 - ref: 'lex:app.rocksky.stats.defs#statsView', 4391 4391 + type: "ref", 4392 4392 + ref: "lex:app.rocksky.stats.defs#statsView", 4373 4393 }, 4374 4394 }, 4375 4395 }, ··· 4377 4397 }, 4378 4398 ComAtprotoRepoStrongRef: { 4379 4399 lexicon: 1, 4380 4380 - id: 'com.atproto.repo.strongRef', 4381 4381 - description: 'A URI with a content-hash fingerprint.', 4400 4400 + id: "com.atproto.repo.strongRef", 4401 4401 + description: "A URI with a content-hash fingerprint.", 4382 4402 defs: { 4383 4403 main: { 4384 4384 - type: 'object', 4385 4385 - required: ['uri', 'cid'], 4404 4404 + type: "object", 4405 4405 + required: ["uri", "cid"], 4386 4406 properties: { 4387 4407 uri: { 4388 4388 - type: 'string', 4389 4389 - format: 'at-uri', 4408 4408 + type: "string", 4409 4409 + format: "at-uri", 4390 4410 }, 4391 4411 cid: { 4392 4392 - type: 'string', 4393 4393 - format: 'cid', 4412 4412 + type: "string", 4413 4413 + format: "cid", 4394 4414 }, 4395 4415 }, 4396 4416 }, 4397 4417 }, 4398 4418 }, 4399 4399 - } as const satisfies Record<string, LexiconDoc> 4419 4419 + } as const satisfies Record<string, LexiconDoc>; 4400 4420 4401 4401 - export const schemas = Object.values(schemaDict) 4402 4402 - export const lexicons: Lexicons = new Lexicons(schemas) 4421 4421 + export const schemas = Object.values(schemaDict); 4422 4422 + export const lexicons: Lexicons = new Lexicons(schemas); 4403 4423 export const ids = { 4404 4404 - AppRockskyActorDefs: 'app.rocksky.actor.defs', 4405 4405 - AppRockskyActorGetActorAlbums: 'app.rocksky.actor.getActorAlbums', 4406 4406 - AppRockskyActorGetActorArtists: 'app.rocksky.actor.getActorArtists', 4407 4407 - AppRockskyActorGetActorLovedSongs: 'app.rocksky.actor.getActorLovedSongs', 4408 4408 - AppRockskyActorGetActorPlaylists: 'app.rocksky.actor.getActorPlaylists', 4409 4409 - AppRockskyActorGetActorScrobbles: 'app.rocksky.actor.getActorScrobbles', 4410 4410 - AppRockskyActorGetActorSongs: 'app.rocksky.actor.getActorSongs', 4411 4411 - AppRockskyActorGetProfile: 'app.rocksky.actor.getProfile', 4412 4412 - AppBskyActorProfile: 'app.bsky.actor.profile', 4413 4413 - AppRockskyAlbum: 'app.rocksky.album', 4414 4414 - AppRockskyAlbumDefs: 'app.rocksky.album.defs', 4415 4415 - AppRockskyAlbumGetAlbum: 'app.rocksky.album.getAlbum', 4416 4416 - AppRockskyAlbumGetAlbums: 'app.rocksky.album.getAlbums', 4417 4417 - AppRockskyAlbumGetAlbumTracks: 'app.rocksky.album.getAlbumTracks', 4418 4418 - AppRockskyApikeyCreateApikey: 'app.rocksky.apikey.createApikey', 4419 4419 - AppRockskyApikeyDefs: 'app.rocksky.apikey.defs', 4420 4420 - AppRockskyApikeysDefs: 'app.rocksky.apikeys.defs', 4421 4421 - AppRockskyApikeyGetApikeys: 'app.rocksky.apikey.getApikeys', 4422 4422 - AppRockskyApikeyRemoveApikey: 'app.rocksky.apikey.removeApikey', 4423 4423 - AppRockskyApikeyUpdateApikey: 'app.rocksky.apikey.updateApikey', 4424 4424 - AppRockskyArtist: 'app.rocksky.artist', 4425 4425 - AppRockskyArtistDefs: 'app.rocksky.artist.defs', 4426 4426 - AppRockskyArtistGetArtistAlbums: 'app.rocksky.artist.getArtistAlbums', 4427 4427 - AppRockskyArtistGetArtist: 'app.rocksky.artist.getArtist', 4428 4428 - AppRockskyArtistGetArtistListeners: 'app.rocksky.artist.getArtistListeners', 4429 4429 - AppRockskyArtistGetArtists: 'app.rocksky.artist.getArtists', 4430 4430 - AppRockskyArtistGetArtistTracks: 'app.rocksky.artist.getArtistTracks', 4431 4431 - AppRockskyChartsDefs: 'app.rocksky.charts.defs', 4432 4432 - AppRockskyChartsGetScrobblesChart: 'app.rocksky.charts.getScrobblesChart', 4433 4433 - AppRockskyDropboxDefs: 'app.rocksky.dropbox.defs', 4434 4434 - AppRockskyDropboxDownloadFile: 'app.rocksky.dropbox.downloadFile', 4435 4435 - AppRockskyDropboxGetFiles: 'app.rocksky.dropbox.getFiles', 4436 4436 - AppRockskyDropboxGetMetadata: 'app.rocksky.dropbox.getMetadata', 4437 4437 - AppRockskyDropboxGetTemporaryLink: 'app.rocksky.dropbox.getTemporaryLink', 4438 4438 - AppRockskyFeedDefs: 'app.rocksky.feed.defs', 4439 4439 - AppRockskyFeedGetNowPlayings: 'app.rocksky.feed.getNowPlayings', 4440 4440 - AppRockskyFeedSearch: 'app.rocksky.feed.search', 4441 4441 - AppRockskyGoogledriveDefs: 'app.rocksky.googledrive.defs', 4442 4442 - AppRockskyGoogledriveDownloadFile: 'app.rocksky.googledrive.downloadFile', 4443 4443 - AppRockskyGoogledriveGetFile: 'app.rocksky.googledrive.getFile', 4444 4444 - AppRockskyGoogledriveGetFiles: 'app.rocksky.googledrive.getFiles', 4445 4445 - AppRockskyLikeDislikeShout: 'app.rocksky.like.dislikeShout', 4446 4446 - AppRockskyLikeDislikeSong: 'app.rocksky.like.dislikeSong', 4447 4447 - AppRockskyLike: 'app.rocksky.like', 4448 4448 - AppRockskyLikeLikeShout: 'app.rocksky.like.likeShout', 4449 4449 - AppRockskyLikeLikeSong: 'app.rocksky.like.likeSong', 4450 4450 - AppRockskyPlayerAddDirectoryToQueue: 'app.rocksky.player.addDirectoryToQueue', 4451 4451 - AppRockskyPlayerAddItemsToQueue: 'app.rocksky.player.addItemsToQueue', 4452 4452 - AppRockskyPlayerDefs: 'app.rocksky.player.defs', 4453 4453 - AppRockskyPlayerGetCurrentlyPlaying: 'app.rocksky.player.getCurrentlyPlaying', 4454 4454 - AppRockskyPlayerGetPlaybackQueue: 'app.rocksky.player.getPlaybackQueue', 4455 4455 - AppRockskyPlayerNext: 'app.rocksky.player.next', 4456 4456 - AppRockskyPlayerPause: 'app.rocksky.player.pause', 4457 4457 - AppRockskyPlayerPlayDirectory: 'app.rocksky.player.playDirectory', 4458 4458 - AppRockskyPlayerPlayFile: 'app.rocksky.player.playFile', 4459 4459 - AppRockskyPlayerPlay: 'app.rocksky.player.play', 4460 4460 - AppRockskyPlayerPrevious: 'app.rocksky.player.previous', 4461 4461 - AppRockskyPlayerSeek: 'app.rocksky.player.seek', 4462 4462 - AppRockskyPlaylistCreatePlaylist: 'app.rocksky.playlist.createPlaylist', 4463 4463 - AppRockskyPlaylistDefs: 'app.rocksky.playlist.defs', 4464 4464 - AppRockskyPlaylistGetPlaylist: 'app.rocksky.playlist.getPlaylist', 4465 4465 - AppRockskyPlaylistGetPlaylists: 'app.rocksky.playlist.getPlaylists', 4466 4466 - AppRockskyPlaylistInsertDirectory: 'app.rocksky.playlist.insertDirectory', 4467 4467 - AppRockskyPlaylistInsertFiles: 'app.rocksky.playlist.insertFiles', 4468 4468 - AppRockskyPlaylist: 'app.rocksky.playlist', 4469 4469 - AppRockskyPlaylistRemovePlaylist: 'app.rocksky.playlist.removePlaylist', 4470 4470 - AppRockskyPlaylistRemoveTrack: 'app.rocksky.playlist.removeTrack', 4471 4471 - AppRockskyPlaylistStartPlaylist: 'app.rocksky.playlist.startPlaylist', 4472 4472 - AppRockskyRadioDefs: 'app.rocksky.radio.defs', 4473 4473 - AppRockskyRadio: 'app.rocksky.radio', 4474 4474 - AppRockskyScrobbleCreateScrobble: 'app.rocksky.scrobble.createScrobble', 4475 4475 - AppRockskyScrobbleDefs: 'app.rocksky.scrobble.defs', 4476 4476 - AppRockskyScrobbleGetScrobble: 'app.rocksky.scrobble.getScrobble', 4477 4477 - AppRockskyScrobbleGetScrobbles: 'app.rocksky.scrobble.getScrobbles', 4478 4478 - AppRockskyScrobble: 'app.rocksky.scrobble', 4479 4479 - AppRockskyShoutCreateShout: 'app.rocksky.shout.createShout', 4480 4480 - AppRockskyShoutDefs: 'app.rocksky.shout.defs', 4481 4481 - AppRockskyShoutGetAlbumShouts: 'app.rocksky.shout.getAlbumShouts', 4482 4482 - AppRockskyShoutGetArtistShouts: 'app.rocksky.shout.getArtistShouts', 4483 4483 - AppRockskyShoutGetProfileShouts: 'app.rocksky.shout.getProfileShouts', 4484 4484 - AppRockskyShoutGetShoutReplies: 'app.rocksky.shout.getShoutReplies', 4485 4485 - AppRockskyShoutGetTrackShouts: 'app.rocksky.shout.getTrackShouts', 4486 4486 - AppRockskyShoutRemoveShout: 'app.rocksky.shout.removeShout', 4487 4487 - AppRockskyShoutReplyShout: 'app.rocksky.shout.replyShout', 4488 4488 - AppRockskyShoutReportShout: 'app.rocksky.shout.reportShout', 4489 4489 - AppRockskyShout: 'app.rocksky.shout', 4490 4490 - AppRockskySongCreateSong: 'app.rocksky.song.createSong', 4491 4491 - AppRockskySongDefs: 'app.rocksky.song.defs', 4492 4492 - AppRockskySongGetSong: 'app.rocksky.song.getSong', 4493 4493 - AppRockskySongGetSongs: 'app.rocksky.song.getSongs', 4494 4494 - AppRockskySong: 'app.rocksky.song', 4495 4495 - AppRockskySpotifyDefs: 'app.rocksky.spotify.defs', 4424 4424 + AppRockskyActorDefs: "app.rocksky.actor.defs", 4425 4425 + AppRockskyActorGetActorAlbums: "app.rocksky.actor.getActorAlbums", 4426 4426 + AppRockskyActorGetActorArtists: "app.rocksky.actor.getActorArtists", 4427 4427 + AppRockskyActorGetActorLovedSongs: "app.rocksky.actor.getActorLovedSongs", 4428 4428 + AppRockskyActorGetActorPlaylists: "app.rocksky.actor.getActorPlaylists", 4429 4429 + AppRockskyActorGetActorScrobbles: "app.rocksky.actor.getActorScrobbles", 4430 4430 + AppRockskyActorGetActorSongs: "app.rocksky.actor.getActorSongs", 4431 4431 + AppRockskyActorGetProfile: "app.rocksky.actor.getProfile", 4432 4432 + AppBskyActorProfile: "app.bsky.actor.profile", 4433 4433 + AppRockskyAlbum: "app.rocksky.album", 4434 4434 + AppRockskyAlbumDefs: "app.rocksky.album.defs", 4435 4435 + AppRockskyAlbumGetAlbum: "app.rocksky.album.getAlbum", 4436 4436 + AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums", 4437 4437 + AppRockskyAlbumGetAlbumTracks: "app.rocksky.album.getAlbumTracks", 4438 4438 + AppRockskyApikeyCreateApikey: "app.rocksky.apikey.createApikey", 4439 4439 + AppRockskyApikeyDefs: "app.rocksky.apikey.defs", 4440 4440 + AppRockskyApikeysDefs: "app.rocksky.apikeys.defs", 4441 4441 + AppRockskyApikeyGetApikeys: "app.rocksky.apikey.getApikeys", 4442 4442 + AppRockskyApikeyRemoveApikey: "app.rocksky.apikey.removeApikey", 4443 4443 + AppRockskyApikeyUpdateApikey: "app.rocksky.apikey.updateApikey", 4444 4444 + AppRockskyArtist: "app.rocksky.artist", 4445 4445 + AppRockskyArtistDefs: "app.rocksky.artist.defs", 4446 4446 + AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums", 4447 4447 + AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist", 4448 4448 + AppRockskyArtistGetArtistListeners: "app.rocksky.artist.getArtistListeners", 4449 4449 + AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists", 4450 4450 + AppRockskyArtistGetArtistTracks: "app.rocksky.artist.getArtistTracks", 4451 4451 + AppRockskyChartsDefs: "app.rocksky.charts.defs", 4452 4452 + AppRockskyChartsGetScrobblesChart: "app.rocksky.charts.getScrobblesChart", 4453 4453 + AppRockskyDropboxDefs: "app.rocksky.dropbox.defs", 4454 4454 + AppRockskyDropboxDownloadFile: "app.rocksky.dropbox.downloadFile", 4455 4455 + AppRockskyDropboxGetFiles: "app.rocksky.dropbox.getFiles", 4456 4456 + AppRockskyDropboxGetMetadata: "app.rocksky.dropbox.getMetadata", 4457 4457 + AppRockskyDropboxGetTemporaryLink: "app.rocksky.dropbox.getTemporaryLink", 4458 4458 + AppRockskyFeedDefs: "app.rocksky.feed.defs", 4459 4459 + AppRockskyFeedGetNowPlayings: "app.rocksky.feed.getNowPlayings", 4460 4460 + AppRockskyFeedSearch: "app.rocksky.feed.search", 4461 4461 + AppRockskyGoogledriveDefs: "app.rocksky.googledrive.defs", 4462 4462 + AppRockskyGoogledriveDownloadFile: "app.rocksky.googledrive.downloadFile", 4463 4463 + AppRockskyGoogledriveGetFile: "app.rocksky.googledrive.getFile", 4464 4464 + AppRockskyGoogledriveGetFiles: "app.rocksky.googledrive.getFiles", 4465 4465 + AppRockskyLikeDislikeShout: "app.rocksky.like.dislikeShout", 4466 4466 + AppRockskyLikeDislikeSong: "app.rocksky.like.dislikeSong", 4467 4467 + AppRockskyLike: "app.rocksky.like", 4468 4468 + AppRockskyLikeLikeShout: "app.rocksky.like.likeShout", 4469 4469 + AppRockskyLikeLikeSong: "app.rocksky.like.likeSong", 4470 4470 + AppRockskyPlayerAddDirectoryToQueue: "app.rocksky.player.addDirectoryToQueue", 4471 4471 + AppRockskyPlayerAddItemsToQueue: "app.rocksky.player.addItemsToQueue", 4472 4472 + AppRockskyPlayerDefs: "app.rocksky.player.defs", 4473 4473 + AppRockskyPlayerGetCurrentlyPlaying: "app.rocksky.player.getCurrentlyPlaying", 4474 4474 + AppRockskyPlayerGetPlaybackQueue: "app.rocksky.player.getPlaybackQueue", 4475 4475 + AppRockskyPlayerNext: "app.rocksky.player.next", 4476 4476 + AppRockskyPlayerPause: "app.rocksky.player.pause", 4477 4477 + AppRockskyPlayerPlayDirectory: "app.rocksky.player.playDirectory", 4478 4478 + AppRockskyPlayerPlayFile: "app.rocksky.player.playFile", 4479 4479 + AppRockskyPlayerPlay: "app.rocksky.player.play", 4480 4480 + AppRockskyPlayerPrevious: "app.rocksky.player.previous", 4481 4481 + AppRockskyPlayerSeek: "app.rocksky.player.seek", 4482 4482 + AppRockskyPlaylistCreatePlaylist: "app.rocksky.playlist.createPlaylist", 4483 4483 + AppRockskyPlaylistDefs: "app.rocksky.playlist.defs", 4484 4484 + AppRockskyPlaylistGetPlaylist: "app.rocksky.playlist.getPlaylist", 4485 4485 + AppRockskyPlaylistGetPlaylists: "app.rocksky.playlist.getPlaylists", 4486 4486 + AppRockskyPlaylistInsertDirectory: "app.rocksky.playlist.insertDirectory", 4487 4487 + AppRockskyPlaylistInsertFiles: "app.rocksky.playlist.insertFiles", 4488 4488 + AppRockskyPlaylist: "app.rocksky.playlist", 4489 4489 + AppRockskyPlaylistRemovePlaylist: "app.rocksky.playlist.removePlaylist", 4490 4490 + AppRockskyPlaylistRemoveTrack: "app.rocksky.playlist.removeTrack", 4491 4491 + AppRockskyPlaylistStartPlaylist: "app.rocksky.playlist.startPlaylist", 4492 4492 + AppRockskyRadioDefs: "app.rocksky.radio.defs", 4493 4493 + AppRockskyRadio: "app.rocksky.radio", 4494 4494 + AppRockskyScrobbleCreateScrobble: "app.rocksky.scrobble.createScrobble", 4495 4495 + AppRockskyScrobbleDefs: "app.rocksky.scrobble.defs", 4496 4496 + AppRockskyScrobbleGetScrobble: "app.rocksky.scrobble.getScrobble", 4497 4497 + AppRockskyScrobbleGetScrobbles: "app.rocksky.scrobble.getScrobbles", 4498 4498 + AppRockskyScrobble: "app.rocksky.scrobble", 4499 4499 + AppRockskyShoutCreateShout: "app.rocksky.shout.createShout", 4500 4500 + AppRockskyShoutDefs: "app.rocksky.shout.defs", 4501 4501 + AppRockskyShoutGetAlbumShouts: "app.rocksky.shout.getAlbumShouts", 4502 4502 + AppRockskyShoutGetArtistShouts: "app.rocksky.shout.getArtistShouts", 4503 4503 + AppRockskyShoutGetProfileShouts: "app.rocksky.shout.getProfileShouts", 4504 4504 + AppRockskyShoutGetShoutReplies: "app.rocksky.shout.getShoutReplies", 4505 4505 + AppRockskyShoutGetTrackShouts: "app.rocksky.shout.getTrackShouts", 4506 4506 + AppRockskyShoutRemoveShout: "app.rocksky.shout.removeShout", 4507 4507 + AppRockskyShoutReplyShout: "app.rocksky.shout.replyShout", 4508 4508 + AppRockskyShoutReportShout: "app.rocksky.shout.reportShout", 4509 4509 + AppRockskyShout: "app.rocksky.shout", 4510 4510 + AppRockskySongCreateSong: "app.rocksky.song.createSong", 4511 4511 + AppRockskySongDefs: "app.rocksky.song.defs", 4512 4512 + AppRockskySongGetSong: "app.rocksky.song.getSong", 4513 4513 + AppRockskySongGetSongs: "app.rocksky.song.getSongs", 4514 4514 + AppRockskySong: "app.rocksky.song", 4515 4515 + AppRockskySpotifyDefs: "app.rocksky.spotify.defs", 4496 4516 AppRockskySpotifyGetCurrentlyPlaying: 4497 4497 - 'app.rocksky.spotify.getCurrentlyPlaying', 4498 4498 - AppRockskySpotifyNext: 'app.rocksky.spotify.next', 4499 4499 - AppRockskySpotifyPause: 'app.rocksky.spotify.pause', 4500 4500 - AppRockskySpotifyPlay: 'app.rocksky.spotify.play', 4501 4501 - AppRockskySpotifyPrevious: 'app.rocksky.spotify.previous', 4502 4502 - AppRockskySpotifySeek: 'app.rocksky.spotify.seek', 4503 4503 - AppRockskyStatsDefs: 'app.rocksky.stats.defs', 4504 4504 - AppRockskyStatsGetStats: 'app.rocksky.stats.getStats', 4505 4505 - ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef', 4506 4506 - } 4517 4517 + "app.rocksky.spotify.getCurrentlyPlaying", 4518 4518 + AppRockskySpotifyNext: "app.rocksky.spotify.next", 4519 4519 + AppRockskySpotifyPause: "app.rocksky.spotify.pause", 4520 4520 + AppRockskySpotifyPlay: "app.rocksky.spotify.play", 4521 4521 + AppRockskySpotifyPrevious: "app.rocksky.spotify.previous", 4522 4522 + AppRockskySpotifySeek: "app.rocksky.spotify.seek", 4523 4523 + AppRockskyStatsDefs: "app.rocksky.stats.defs", 4524 4524 + AppRockskyStatsGetStats: "app.rocksky.stats.getStats", 4525 4525 + ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef", 4526 4526 + };

+19 -19

apps/api/src/lexicon/types/app/bsky/actor/profile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs' 9 9 - import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs"; 9 9 + import * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef"; 10 10 11 11 export interface Record { 12 12 - displayName?: string 12 12 + displayName?: string; 13 13 /** Free-form profile description text. */ 14 14 - description?: string 14 14 + description?: string; 15 15 /** Small image to be displayed next to posts from account. AKA, 'profile picture' */ 16 16 - avatar?: BlobRef 16 16 + avatar?: BlobRef; 17 17 /** Larger horizontal image to display behind profile view. */ 18 18 - banner?: BlobRef 18 18 + banner?: BlobRef; 19 19 labels?: 20 20 | ComAtprotoLabelDefs.SelfLabels 21 21 - | { $type: string; [k: string]: unknown } 22 22 - joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main 23 23 - createdAt?: string 24 24 - [k: string]: unknown 21 21 + | { $type: string; [k: string]: unknown }; 22 22 + joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main; 23 23 + createdAt?: string; 24 24 + [k: string]: unknown; 25 25 } 26 26 27 27 export function isRecord(v: unknown): v is Record { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, '$type') && 31 31 - (v.$type === 'app.bsky.actor.profile#main' || 32 32 - v.$type === 'app.bsky.actor.profile') 33 33 - ) 30 30 + hasProp(v, "$type") && 31 31 + (v.$type === "app.bsky.actor.profile#main" || 32 32 + v.$type === "app.bsky.actor.profile") 33 33 + ); 34 34 } 35 35 36 36 export function validateRecord(v: unknown): ValidationResult { 37 37 - return lexicons.validate('app.bsky.actor.profile#main', v) 37 37 + return lexicons.validate("app.bsky.actor.profile#main", v); 38 38 }

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface ProfileViewDetailed { 10 10 /** The unique identifier of the actor. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The DID of the actor. */ 13 13 - did?: string 13 13 + did?: string; 14 14 /** The handle of the actor. */ 15 15 - handle?: string 15 15 + handle?: string; 16 16 /** The display name of the actor. */ 17 17 - displayName?: string 17 17 + displayName?: string; 18 18 /** The URL of the actor's avatar image. */ 19 19 - avatar?: string 19 19 + avatar?: string; 20 20 /** The date and time when the actor was created. */ 21 21 - createdAt?: string 21 21 + createdAt?: string; 22 22 /** The date and time when the actor was last updated. */ 23 23 - updatedAt?: string 24 24 - [k: string]: unknown 23 23 + updatedAt?: string; 24 24 + [k: string]: unknown; 25 25 } 26 26 27 27 export function isProfileViewDetailed(v: unknown): v is ProfileViewDetailed { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, '$type') && 31 31 - v.$type === 'app.rocksky.actor.defs#profileViewDetailed' 32 32 - ) 30 30 + hasProp(v, "$type") && 31 31 + v.$type === "app.rocksky.actor.defs#profileViewDetailed" 32 32 + ); 33 33 } 34 34 35 35 export function validateProfileViewDetailed(v: unknown): ValidationResult { 36 36 - return lexicons.validate('app.rocksky.actor.defs#profileViewDetailed', v) 36 36 + return lexicons.validate("app.rocksky.actor.defs#profileViewDetailed", v); 37 37 } 38 38 39 39 export interface ProfileViewBasic { 40 40 /** The unique identifier of the actor. */ 41 41 - id?: string 41 41 + id?: string; 42 42 /** The DID of the actor. */ 43 43 - did?: string 43 43 + did?: string; 44 44 /** The handle of the actor. */ 45 45 - handle?: string 45 45 + handle?: string; 46 46 /** The display name of the actor. */ 47 47 - displayName?: string 47 47 + displayName?: string; 48 48 /** The URL of the actor's avatar image. */ 49 49 - avatar?: string 49 49 + avatar?: string; 50 50 /** The date and time when the actor was created. */ 51 51 - createdAt?: string 51 51 + createdAt?: string; 52 52 /** The date and time when the actor was last updated. */ 53 53 - updatedAt?: string 54 54 - [k: string]: unknown 53 53 + updatedAt?: string; 54 54 + [k: string]: unknown; 55 55 } 56 56 57 57 export function isProfileViewBasic(v: unknown): v is ProfileViewBasic { 58 58 return ( 59 59 isObj(v) && 60 60 - hasProp(v, '$type') && 61 61 - v.$type === 'app.rocksky.actor.defs#profileViewBasic' 62 62 - ) 60 60 + hasProp(v, "$type") && 61 61 + v.$type === "app.rocksky.actor.defs#profileViewBasic" 62 62 + ); 63 63 } 64 64 65 65 export function validateProfileViewBasic(v: unknown): ValidationResult { 66 66 - return lexicons.validate('app.rocksky.actor.defs#profileViewBasic', v) 66 66 + return lexicons.validate("app.rocksky.actor.defs#profileViewBasic", v); 67 67 }

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorAlbums.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyAlbumDefs from '../album/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyAlbumDefs from "../album/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - albums?: AppRockskyAlbumDefs.AlbumViewBasic[] 25 25 - [k: string]: unknown 24 24 + albums?: AppRockskyAlbumDefs.AlbumViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorArtists.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyArtistDefs from '../artist/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyArtistDefs from "../artist/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - artists?: AppRockskyArtistDefs.ArtistViewBasic[] 25 25 - [k: string]: unknown 24 24 + artists?: AppRockskyArtistDefs.ArtistViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorLovedSongs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - tracks?: AppRockskySongDefs.SongViewBasic[] 25 25 - [k: string]: unknown 24 24 + tracks?: AppRockskySongDefs.SongViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorPlaylists.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlaylistDefs from '../playlist/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlaylistDefs from "../playlist/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[] 25 25 - [k: string]: unknown 24 24 + playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorScrobbles.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyScrobbleDefs from '../scrobble/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyScrobbleDefs from "../scrobble/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[] 25 25 - [k: string]: unknown 24 24 + scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/actor/getActorSongs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The maximum number of albums to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - songs?: AppRockskySongDefs.SongViewBasic[] 25 25 - [k: string]: unknown 24 24 + songs?: AppRockskySongDefs.SongViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/actor/getProfile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyActorDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyActorDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did?: string 14 14 + did?: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyActorDefs.ProfileViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyActorDefs.ProfileViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+24 -22

apps/api/src/lexicon/types/app/rocksky/album.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Record { 10 10 /** The title of the album. */ 11 11 - title: string 11 11 + title: string; 12 12 /** The artist of the album. */ 13 13 - artist: string 13 13 + artist: string; 14 14 /** The duration of the album in seconds. */ 15 15 - duration?: number 15 15 + duration?: number; 16 16 /** The release date of the album. */ 17 17 - releaseDate?: string 17 17 + releaseDate?: string; 18 18 /** The year the album was released. */ 19 19 - year?: number 19 19 + year?: number; 20 20 /** The genre of the album. */ 21 21 - genre?: string 21 21 + genre?: string; 22 22 /** The album art of the album. */ 23 23 - albumArt?: BlobRef 23 23 + albumArt?: BlobRef; 24 24 + /** The URL of the album art of the album. */ 25 25 + albumArtUrl?: string; 24 26 /** The tags of the album. */ 25 25 - tags?: string[] 27 27 + tags?: string[]; 26 28 /** The YouTube link of the album. */ 27 27 - youtubeLink?: string 29 29 + youtubeLink?: string; 28 30 /** The Spotify link of the album. */ 29 29 - spotifyLink?: string 31 31 + spotifyLink?: string; 30 32 /** The tidal link of the album. */ 31 31 - tidalLink?: string 33 33 + tidalLink?: string; 32 34 /** The Apple Music link of the album. */ 33 33 - appleMusicLink?: string 35 35 + appleMusicLink?: string; 34 36 /** The date and time when the album was created. */ 35 35 - createdAt: string 36 36 - [k: string]: unknown 37 37 + createdAt: string; 38 38 + [k: string]: unknown; 37 39 } 38 40 39 41 export function isRecord(v: unknown): v is Record { 40 42 return ( 41 43 isObj(v) && 42 42 - hasProp(v, '$type') && 43 43 - (v.$type === 'app.rocksky.album#main' || v.$type === 'app.rocksky.album') 44 44 - ) 44 44 + hasProp(v, "$type") && 45 45 + (v.$type === "app.rocksky.album#main" || v.$type === "app.rocksky.album") 46 46 + ); 45 47 } 46 48 47 49 export function validateRecord(v: unknown): ValidationResult { 48 48 - return lexicons.validate('app.rocksky.album#main', v) 50 50 + return lexicons.validate("app.rocksky.album#main", v); 49 51 }

+38 -38

apps/api/src/lexicon/types/app/rocksky/album/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as AppRockskySongDefsSongViewBasic from '../song/defs/songViewBasic' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as AppRockskySongDefsSongViewBasic from "../song/defs/songViewBasic"; 9 9 10 10 export interface AlbumViewBasic { 11 11 /** The unique identifier of the album. */ 12 12 - id?: string 12 12 + id?: string; 13 13 /** The URI of the album. */ 14 14 - uri?: string 14 14 + uri?: string; 15 15 /** The title of the album. */ 16 16 - title?: string 16 16 + title?: string; 17 17 /** The artist of the album. */ 18 18 - artist?: string 18 18 + artist?: string; 19 19 /** The URI of the album's artist. */ 20 20 - artistUri?: string 20 20 + artistUri?: string; 21 21 /** The year the album was released. */ 22 22 - year?: number 22 22 + year?: number; 23 23 /** The URL of the album art image. */ 24 24 - albumArt?: string 24 24 + albumArt?: string; 25 25 /** The release date of the album. */ 26 26 - releaseDate?: string 26 26 + releaseDate?: string; 27 27 /** The SHA256 hash of the album. */ 28 28 - sha256?: string 28 28 + sha256?: string; 29 29 /** The number of times the album has been played. */ 30 30 - playCount?: number 30 30 + playCount?: number; 31 31 /** The number of unique listeners who have played the album. */ 32 32 - uniqueListeners?: number 33 33 - [k: string]: unknown 32 32 + uniqueListeners?: number; 33 33 + [k: string]: unknown; 34 34 } 35 35 36 36 export function isAlbumViewBasic(v: unknown): v is AlbumViewBasic { 37 37 return ( 38 38 isObj(v) && 39 39 - hasProp(v, '$type') && 40 40 - v.$type === 'app.rocksky.album.defs#albumViewBasic' 41 41 - ) 39 39 + hasProp(v, "$type") && 40 40 + v.$type === "app.rocksky.album.defs#albumViewBasic" 41 41 + ); 42 42 } 43 43 44 44 export function validateAlbumViewBasic(v: unknown): ValidationResult { 45 45 - return lexicons.validate('app.rocksky.album.defs#albumViewBasic', v) 45 45 + return lexicons.validate("app.rocksky.album.defs#albumViewBasic", v); 46 46 } 47 47 48 48 export interface AlbumViewDetailed { 49 49 /** The unique identifier of the album. */ 50 50 - id?: string 50 50 + id?: string; 51 51 /** The URI of the album. */ 52 52 - uri?: string 52 52 + uri?: string; 53 53 /** The title of the album. */ 54 54 - title?: string 54 54 + title?: string; 55 55 /** The artist of the album. */ 56 56 - artist?: string 56 56 + artist?: string; 57 57 /** The URI of the album's artist. */ 58 58 - artistUri?: string 58 58 + artistUri?: string; 59 59 /** The year the album was released. */ 60 60 - year?: number 60 60 + year?: number; 61 61 /** The URL of the album art image. */ 62 62 - albumArt?: string 62 62 + albumArt?: string; 63 63 /** The release date of the album. */ 64 64 - releaseDate?: string 64 64 + releaseDate?: string; 65 65 /** The SHA256 hash of the album. */ 66 66 - sha256?: string 66 66 + sha256?: string; 67 67 /** The number of times the album has been played. */ 68 68 - playCount?: number 68 68 + playCount?: number; 69 69 /** The number of unique listeners who have played the album. */ 70 70 - uniqueListeners?: number 71 71 - tracks?: AppRockskySongDefsSongViewBasic.Main[] 72 72 - [k: string]: unknown 70 70 + uniqueListeners?: number; 71 71 + tracks?: AppRockskySongDefsSongViewBasic.Main[]; 72 72 + [k: string]: unknown; 73 73 } 74 74 75 75 export function isAlbumViewDetailed(v: unknown): v is AlbumViewDetailed { 76 76 return ( 77 77 isObj(v) && 78 78 - hasProp(v, '$type') && 79 79 - v.$type === 'app.rocksky.album.defs#albumViewDetailed' 80 80 - ) 78 78 + hasProp(v, "$type") && 79 79 + v.$type === "app.rocksky.album.defs#albumViewDetailed" 80 80 + ); 81 81 } 82 82 83 83 export function validateAlbumViewDetailed(v: unknown): ValidationResult { 84 84 - return lexicons.validate('app.rocksky.album.defs#albumViewDetailed', v) 84 84 + return lexicons.validate("app.rocksky.album.defs#albumViewDetailed", v); 85 85 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/album/getAlbum.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyAlbumDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyAlbumDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the album to retrieve. */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyAlbumDefs.AlbumViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyAlbumDefs.AlbumViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+26 -26

apps/api/src/lexicon/types/app/rocksky/album/getAlbumTracks.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the album to retrieve tracks from */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 17 17 + export type InputSchema = undefined; 18 18 19 19 export interface OutputSchema { 20 20 - tracks?: AppRockskySongDefs.SongViewBasic[] 21 21 - [k: string]: unknown 20 20 + tracks?: AppRockskySongDefs.SongViewBasic[]; 21 21 + [k: string]: unknown; 22 22 } 23 23 24 24 - export type HandlerInput = undefined 24 24 + export type HandlerInput = undefined; 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: 'application/json' 28 28 - body: OutputSchema 29 29 - headers?: { [key: string]: string } 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number 34 34 - message?: string 33 33 + status: number; 34 34 + message?: string; 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA 40 40 - params: QueryParams 41 41 - input: HandlerInput 42 42 - req: express.Request 43 43 - res: express.Response 44 44 - resetRouteRateLimits: () => Promise<void> 45 45 - } 39 39 + auth: HA; 40 40 + params: QueryParams; 41 41 + input: HandlerInput; 42 42 + req: express.Request; 43 43 + res: express.Response; 44 44 + resetRouteRateLimits: () => Promise<void>; 45 45 + }; 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput 48 48 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/album/getAlbums.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyAlbumDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyAlbumDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of albums to return */ 14 14 - limit?: number 14 14 + limit?: number; 15 15 /** The offset for pagination */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 19 19 + export type InputSchema = undefined; 20 20 21 21 export interface OutputSchema { 22 22 - albums?: AppRockskyAlbumDefs.AlbumViewBasic[] 23 23 - [k: string]: unknown 22 22 + albums?: AppRockskyAlbumDefs.AlbumViewBasic[]; 23 23 + [k: string]: unknown; 24 24 } 25 25 26 26 - export type HandlerInput = undefined 26 26 + export type HandlerInput = undefined; 27 27 28 28 export interface HandlerSuccess { 29 29 - encoding: 'application/json' 30 30 - body: OutputSchema 31 31 - headers?: { [key: string]: string } 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 } 33 33 34 34 export interface HandlerError { 35 35 - status: number 36 36 - message?: string 35 35 + status: number; 36 36 + message?: string; 37 37 } 38 38 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA 42 42 - params: QueryParams 43 43 - input: HandlerInput 44 44 - req: express.Request 45 45 - res: express.Response 46 46 - resetRouteRateLimits: () => Promise<void> 47 47 - } 41 41 + auth: HA; 42 42 + params: QueryParams; 43 43 + input: HandlerInput; 44 44 + req: express.Request; 45 45 + res: express.Response; 46 46 + resetRouteRateLimits: () => Promise<void>; 47 47 + }; 48 48 export type Handler<HA extends HandlerAuth = never> = ( 49 49 ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput 50 50 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/apikey/createApikey.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyApikeyDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyApikeyDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The name of the API key. */ 16 16 - name: string 16 16 + name: string; 17 17 /** A description for the API key. */ 18 18 - description?: string 19 19 - [k: string]: unknown 18 18 + description?: string; 19 19 + [k: string]: unknown; 20 20 } 21 21 22 22 - export type OutputSchema = AppRockskyApikeyDefs.ApiKey 22 22 + export type OutputSchema = AppRockskyApikeyDefs.ApiKey; 23 23 24 24 export interface HandlerInput { 25 25 - encoding: 'application/json' 26 26 - body: InputSchema 25 25 + encoding: "application/json"; 26 26 + body: InputSchema; 27 27 } 28 28 29 29 export interface HandlerSuccess { 30 30 - encoding: 'application/json' 31 31 - body: OutputSchema 32 32 - headers?: { [key: string]: string } 30 30 + encoding: "application/json"; 31 31 + body: OutputSchema; 32 32 + headers?: { [key: string]: string }; 33 33 } 34 34 35 35 export interface HandlerError { 36 36 - status: number 37 37 - message?: string 36 36 + status: number; 37 37 + message?: string; 38 38 } 39 39 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA 43 43 - params: QueryParams 44 44 - input: HandlerInput 45 45 - req: express.Request 46 46 - res: express.Response 47 47 - resetRouteRateLimits: () => Promise<void> 48 48 - } 42 42 + auth: HA; 43 43 + params: QueryParams; 44 44 + input: HandlerInput; 45 45 + req: express.Request; 46 46 + res: express.Response; 47 47 + resetRouteRateLimits: () => Promise<void>; 48 48 + }; 49 49 export type Handler<HA extends HandlerAuth = never> = ( 50 50 ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput 51 51 + ) => Promise<HandlerOutput> | HandlerOutput;

+13 -13

apps/api/src/lexicon/types/app/rocksky/apikey/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface ApiKeyView { 10 10 /** The unique identifier of the API key. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The name of the API key. */ 13 13 - name?: string 13 13 + name?: string; 14 14 /** A description for the API key. */ 15 15 - description?: string 15 15 + description?: string; 16 16 /** The date and time when the API key was created. */ 17 17 - createdAt?: string 18 18 - [k: string]: unknown 17 17 + createdAt?: string; 18 18 + [k: string]: unknown; 19 19 } 20 20 21 21 export function isApiKeyView(v: unknown): v is ApiKeyView { 22 22 return ( 23 23 isObj(v) && 24 24 - hasProp(v, '$type') && 25 25 - v.$type === 'app.rocksky.apikey.defs#apiKeyView' 26 26 - ) 24 24 + hasProp(v, "$type") && 25 25 + v.$type === "app.rocksky.apikey.defs#apiKeyView" 26 26 + ); 27 27 } 28 28 29 29 export function validateApiKeyView(v: unknown): ValidationResult { 30 30 - return lexicons.validate('app.rocksky.apikey.defs#apiKeyView', v) 30 30 + return lexicons.validate("app.rocksky.apikey.defs#apiKeyView", v); 31 31 }

+27 -27

apps/api/src/lexicon/types/app/rocksky/apikey/getApikeys.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyApikeyDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyApikeyDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The number of API keys to skip before starting to collect the result set. */ 14 14 - offset?: number 14 14 + offset?: number; 15 15 /** The number of API keys to return per page. */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 19 19 + export type InputSchema = undefined; 20 20 21 21 export interface OutputSchema { 22 22 - apiKeys?: AppRockskyApikeyDefs.ApikeyView[] 23 23 - [k: string]: unknown 22 22 + apiKeys?: AppRockskyApikeyDefs.ApikeyView[]; 23 23 + [k: string]: unknown; 24 24 } 25 25 26 26 - export type HandlerInput = undefined 26 26 + export type HandlerInput = undefined; 27 27 28 28 export interface HandlerSuccess { 29 29 - encoding: 'application/json' 30 30 - body: OutputSchema 31 31 - headers?: { [key: string]: string } 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 } 33 33 34 34 export interface HandlerError { 35 35 - status: number 36 36 - message?: string 35 35 + status: number; 36 36 + message?: string; 37 37 } 38 38 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA 42 42 - params: QueryParams 43 43 - input: HandlerInput 44 44 - req: express.Request 45 45 - res: express.Response 46 46 - resetRouteRateLimits: () => Promise<void> 47 47 - } 41 41 + auth: HA; 42 42 + params: QueryParams; 43 43 + input: HandlerInput; 44 44 + req: express.Request; 45 45 + res: express.Response; 46 46 + resetRouteRateLimits: () => Promise<void>; 47 47 + }; 48 48 export type Handler<HA extends HandlerAuth = never> = ( 49 49 ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput 50 50 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/apikey/removeApikey.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyApikeyDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyApikeyDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the API key to remove. */ 14 14 - id: string 14 14 + id: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyApikeyDefs.ApiKey 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyApikeyDefs.ApiKey; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+29 -29

apps/api/src/lexicon/types/app/rocksky/apikey/updateApikey.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyApikeyDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyApikeyDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The ID of the API key to update. */ 16 16 - id: string 16 16 + id: string; 17 17 /** The new name of the API key. */ 18 18 - name: string 18 18 + name: string; 19 19 /** A new description for the API key. */ 20 20 - description?: string 21 21 - [k: string]: unknown 20 20 + description?: string; 21 21 + [k: string]: unknown; 22 22 } 23 23 24 24 - export type OutputSchema = AppRockskyApikeyDefs.ApiKey 24 24 + export type OutputSchema = AppRockskyApikeyDefs.ApiKey; 25 25 26 26 export interface HandlerInput { 27 27 - encoding: 'application/json' 28 28 - body: InputSchema 27 27 + encoding: "application/json"; 28 28 + body: InputSchema; 29 29 } 30 30 31 31 export interface HandlerSuccess { 32 32 - encoding: 'application/json' 33 33 - body: OutputSchema 34 34 - headers?: { [key: string]: string } 32 32 + encoding: "application/json"; 33 33 + body: OutputSchema; 34 34 + headers?: { [key: string]: string }; 35 35 } 36 36 37 37 export interface HandlerError { 38 38 - status: number 39 39 - message?: string 38 38 + status: number; 39 39 + message?: string; 40 40 } 41 41 42 42 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 43 43 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 44 44 - auth: HA 45 45 - params: QueryParams 46 46 - input: HandlerInput 47 47 - req: express.Request 48 48 - res: express.Response 49 49 - resetRouteRateLimits: () => Promise<void> 50 50 - } 44 44 + auth: HA; 45 45 + params: QueryParams; 46 46 + input: HandlerInput; 47 47 + req: express.Request; 48 48 + res: express.Response; 49 49 + resetRouteRateLimits: () => Promise<void>; 50 50 + }; 51 51 export type Handler<HA extends HandlerAuth = never> = ( 52 52 ctx: HandlerReqCtx<HA>, 53 53 - ) => Promise<HandlerOutput> | HandlerOutput 53 53 + ) => Promise<HandlerOutput> | HandlerOutput;

+4 -4

apps/api/src/lexicon/types/app/rocksky/apikeys/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid";

+19 -17

apps/api/src/lexicon/types/app/rocksky/artist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Record { 10 10 /** The name of the artist. */ 11 11 - name: string 11 11 + name: string; 12 12 /** The biography of the artist. */ 13 13 - bio?: string 13 13 + bio?: string; 14 14 /** The picture of the artist. */ 15 15 - picture?: BlobRef 15 15 + picture?: BlobRef; 16 16 + /** The URL of the picture of the artist. */ 17 17 + pictureUrl?: string; 16 18 /** The tags of the artist. */ 17 17 - tags?: string[] 19 19 + tags?: string[]; 18 20 /** The birth date of the artist. */ 19 19 - born?: string 21 21 + born?: string; 20 22 /** The death date of the artist. */ 21 21 - died?: string 23 23 + died?: string; 22 24 /** The birth place of the artist. */ 23 23 - bornIn?: string 25 25 + bornIn?: string; 24 26 /** The date when the artist was created. */ 25 25 - createdAt: string 26 26 - [k: string]: unknown 27 27 + createdAt: string; 28 28 + [k: string]: unknown; 27 29 } 28 30 29 31 export function isRecord(v: unknown): v is Record { 30 32 return ( 31 33 isObj(v) && 32 32 - hasProp(v, '$type') && 33 33 - (v.$type === 'app.rocksky.artist#main' || v.$type === 'app.rocksky.artist') 34 34 - ) 34 34 + hasProp(v, "$type") && 35 35 + (v.$type === "app.rocksky.artist#main" || v.$type === "app.rocksky.artist") 36 36 + ); 35 37 } 36 38 37 39 export function validateRecord(v: unknown): ValidationResult { 38 38 - return lexicons.validate('app.rocksky.artist#main', v) 40 40 + return lexicons.validate("app.rocksky.artist#main", v); 39 41 }

+49 -49

apps/api/src/lexicon/types/app/rocksky/artist/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface ArtistViewBasic { 10 10 /** The unique identifier of the artist. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The URI of the artist. */ 13 13 - uri?: string 13 13 + uri?: string; 14 14 /** The name of the artist. */ 15 15 - name?: string 15 15 + name?: string; 16 16 /** The picture of the artist. */ 17 17 - picture?: string 17 17 + picture?: string; 18 18 /** The SHA256 hash of the artist. */ 19 19 - sha256?: string 19 19 + sha256?: string; 20 20 /** The number of times the artist has been played. */ 21 21 - playCount?: number 21 21 + playCount?: number; 22 22 /** The number of unique listeners who have played the artist. */ 23 23 - uniqueListeners?: number 24 24 - [k: string]: unknown 23 23 + uniqueListeners?: number; 24 24 + [k: string]: unknown; 25 25 } 26 26 27 27 export function isArtistViewBasic(v: unknown): v is ArtistViewBasic { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, '$type') && 31 31 - v.$type === 'app.rocksky.artist.defs#artistViewBasic' 32 32 - ) 30 30 + hasProp(v, "$type") && 31 31 + v.$type === "app.rocksky.artist.defs#artistViewBasic" 32 32 + ); 33 33 } 34 34 35 35 export function validateArtistViewBasic(v: unknown): ValidationResult { 36 36 - return lexicons.validate('app.rocksky.artist.defs#artistViewBasic', v) 36 36 + return lexicons.validate("app.rocksky.artist.defs#artistViewBasic", v); 37 37 } 38 38 39 39 export interface ArtistViewDetailed { 40 40 /** The unique identifier of the artist. */ 41 41 - id?: string 41 41 + id?: string; 42 42 /** The URI of the artist. */ 43 43 - uri?: string 43 43 + uri?: string; 44 44 /** The name of the artist. */ 45 45 - name?: string 45 45 + name?: string; 46 46 /** The picture of the artist. */ 47 47 - picture?: string 47 47 + picture?: string; 48 48 /** The SHA256 hash of the artist. */ 49 49 - sha256?: string 49 49 + sha256?: string; 50 50 /** The number of times the artist has been played. */ 51 51 - playCount?: number 51 51 + playCount?: number; 52 52 /** The number of unique listeners who have played the artist. */ 53 53 - uniqueListeners?: number 54 54 - [k: string]: unknown 53 53 + uniqueListeners?: number; 54 54 + [k: string]: unknown; 55 55 } 56 56 57 57 export function isArtistViewDetailed(v: unknown): v is ArtistViewDetailed { 58 58 return ( 59 59 isObj(v) && 60 60 - hasProp(v, '$type') && 61 61 - v.$type === 'app.rocksky.artist.defs#artistViewDetailed' 62 62 - ) 60 60 + hasProp(v, "$type") && 61 61 + v.$type === "app.rocksky.artist.defs#artistViewDetailed" 62 62 + ); 63 63 } 64 64 65 65 export function validateArtistViewDetailed(v: unknown): ValidationResult { 66 66 - return lexicons.validate('app.rocksky.artist.defs#artistViewDetailed', v) 66 66 + return lexicons.validate("app.rocksky.artist.defs#artistViewDetailed", v); 67 67 } 68 68 69 69 export interface SongViewBasic { 70 70 /** The URI of the song. */ 71 71 - uri?: string 71 71 + uri?: string; 72 72 /** The title of the song. */ 73 73 - title?: string 73 73 + title?: string; 74 74 /** The number of times the song has been played. */ 75 75 - playCount?: number 76 76 - [k: string]: unknown 75 75 + playCount?: number; 76 76 + [k: string]: unknown; 77 77 } 78 78 79 79 export function isSongViewBasic(v: unknown): v is SongViewBasic { 80 80 return ( 81 81 isObj(v) && 82 82 - hasProp(v, '$type') && 83 83 - v.$type === 'app.rocksky.artist.defs#songViewBasic' 84 84 - ) 82 82 + hasProp(v, "$type") && 83 83 + v.$type === "app.rocksky.artist.defs#songViewBasic" 84 84 + ); 85 85 } 86 86 87 87 export function validateSongViewBasic(v: unknown): ValidationResult { 88 88 - return lexicons.validate('app.rocksky.artist.defs#songViewBasic', v) 88 88 + return lexicons.validate("app.rocksky.artist.defs#songViewBasic", v); 89 89 } 90 90 91 91 export interface ListenerViewBasic { 92 92 /** The unique identifier of the actor. */ 93 93 - id?: string 93 93 + id?: string; 94 94 /** The DID of the listener. */ 95 95 - did?: string 95 95 + did?: string; 96 96 /** The handle of the listener. */ 97 97 - handle?: string 97 97 + handle?: string; 98 98 /** The display name of the listener. */ 99 99 - displayName?: string 99 99 + displayName?: string; 100 100 /** The URL of the listener's avatar image. */ 101 101 - avatar?: string 102 102 - mostListenedSong?: SongViewBasic 101 101 + avatar?: string; 102 102 + mostListenedSong?: SongViewBasic; 103 103 /** The total number of plays by the listener. */ 104 104 - totalPlays?: number 104 104 + totalPlays?: number; 105 105 /** The rank of the listener among all listeners of the artist. */ 106 106 - rank?: number 107 107 - [k: string]: unknown 106 106 + rank?: number; 107 107 + [k: string]: unknown; 108 108 } 109 109 110 110 export function isListenerViewBasic(v: unknown): v is ListenerViewBasic { 111 111 return ( 112 112 isObj(v) && 113 113 - hasProp(v, '$type') && 114 114 - v.$type === 'app.rocksky.artist.defs#listenerViewBasic' 115 115 - ) 113 113 + hasProp(v, "$type") && 114 114 + v.$type === "app.rocksky.artist.defs#listenerViewBasic" 115 115 + ); 116 116 } 117 117 118 118 export function validateListenerViewBasic(v: unknown): ValidationResult { 119 119 - return lexicons.validate('app.rocksky.artist.defs#listenerViewBasic', v) 119 119 + return lexicons.validate("app.rocksky.artist.defs#listenerViewBasic", v); 120 120 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/artist/getArtist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyArtistDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyArtistDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the artist to retrieve details from */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyArtistDefs.ArtistViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyArtistDefs.ArtistViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+26 -26

apps/api/src/lexicon/types/app/rocksky/artist/getArtistAlbums.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyAlbumDefs from '../album/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyAlbumDefs from "../album/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the artist to retrieve albums from */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 17 17 + export type InputSchema = undefined; 18 18 19 19 export interface OutputSchema { 20 20 - albums?: AppRockskyAlbumDefs.AlbumViewBasic[] 21 21 - [k: string]: unknown 20 20 + albums?: AppRockskyAlbumDefs.AlbumViewBasic[]; 21 21 + [k: string]: unknown; 22 22 } 23 23 24 24 - export type HandlerInput = undefined 24 24 + export type HandlerInput = undefined; 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: 'application/json' 28 28 - body: OutputSchema 29 29 - headers?: { [key: string]: string } 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number 34 34 - message?: string 33 33 + status: number; 34 34 + message?: string; 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA 40 40 - params: QueryParams 41 41 - input: HandlerInput 42 42 - req: express.Request 43 43 - res: express.Response 44 44 - resetRouteRateLimits: () => Promise<void> 45 45 - } 39 39 + auth: HA; 40 40 + params: QueryParams; 41 41 + input: HandlerInput; 42 42 + req: express.Request; 43 43 + res: express.Response; 44 44 + resetRouteRateLimits: () => Promise<void>; 45 45 + }; 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput 48 48 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/artist/getArtistListeners.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyArtistDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyArtistDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the artist to retrieve listeners from */ 14 14 - uri: string 14 14 + uri: string; 15 15 /** Number of items to skip before returning results */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 /** Maximum number of results to return */ 18 18 - limit?: number 18 18 + limit?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - listeners?: AppRockskyArtistDefs.ListenerViewBasic[] 25 25 - [k: string]: unknown 24 24 + listeners?: AppRockskyArtistDefs.ListenerViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/artist/getArtistTracks.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the artist to retrieve albums from */ 14 14 - uri?: string 14 14 + uri?: string; 15 15 /** The maximum number of tracks to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - tracks?: AppRockskySongDefs.SongViewBasic[] 25 25 - [k: string]: unknown 24 24 + tracks?: AppRockskySongDefs.SongViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/artist/getArtists.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyArtistDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyArtistDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of artists to return */ 14 14 - limit?: number 14 14 + limit?: number; 15 15 /** The offset for pagination */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 19 19 + export type InputSchema = undefined; 20 20 21 21 export interface OutputSchema { 22 22 - artists?: AppRockskyArtistDefs.ArtistViewBasic[] 23 23 - [k: string]: unknown 22 22 + artists?: AppRockskyArtistDefs.ArtistViewBasic[]; 23 23 + [k: string]: unknown; 24 24 } 25 25 26 26 - export type HandlerInput = undefined 26 26 + export type HandlerInput = undefined; 27 27 28 28 export interface HandlerSuccess { 29 29 - encoding: 'application/json' 30 30 - body: OutputSchema 31 31 - headers?: { [key: string]: string } 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 } 33 33 34 34 export interface HandlerError { 35 35 - status: number 36 36 - message?: string 35 35 + status: number; 36 36 + message?: string; 37 37 } 38 38 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA 42 42 - params: QueryParams 43 43 - input: HandlerInput 44 44 - req: express.Request 45 45 - res: express.Response 46 46 - resetRouteRateLimits: () => Promise<void> 47 47 - } 41 41 + auth: HA; 42 42 + params: QueryParams; 43 43 + input: HandlerInput; 44 44 + req: express.Request; 45 45 + res: express.Response; 46 46 + resetRouteRateLimits: () => Promise<void>; 47 47 + }; 48 48 export type Handler<HA extends HandlerAuth = never> = ( 49 49 ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput 50 50 + ) => Promise<HandlerOutput> | HandlerOutput;

+17 -17

apps/api/src/lexicon/types/app/rocksky/charts/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface ChartsView { 10 10 - scrobbles?: ScrobbleViewBasic[] 11 11 - [k: string]: unknown 10 10 + scrobbles?: ScrobbleViewBasic[]; 11 11 + [k: string]: unknown; 12 12 } 13 13 14 14 export function isChartsView(v: unknown): v is ChartsView { 15 15 return ( 16 16 isObj(v) && 17 17 - hasProp(v, '$type') && 18 18 - v.$type === 'app.rocksky.charts.defs#chartsView' 19 19 - ) 17 17 + hasProp(v, "$type") && 18 18 + v.$type === "app.rocksky.charts.defs#chartsView" 19 19 + ); 20 20 } 21 21 22 22 export function validateChartsView(v: unknown): ValidationResult { 23 23 - return lexicons.validate('app.rocksky.charts.defs#chartsView', v) 23 23 + return lexicons.validate("app.rocksky.charts.defs#chartsView", v); 24 24 } 25 25 26 26 export interface ScrobbleViewBasic { 27 27 /** The date of the scrobble. */ 28 28 - date?: string 28 28 + date?: string; 29 29 /** The number of scrobbles on this date. */ 30 30 - count?: number 31 31 - [k: string]: unknown 30 30 + count?: number; 31 31 + [k: string]: unknown; 32 32 } 33 33 34 34 export function isScrobbleViewBasic(v: unknown): v is ScrobbleViewBasic { 35 35 return ( 36 36 isObj(v) && 37 37 - hasProp(v, '$type') && 38 38 - v.$type === 'app.rocksky.charts.defs#scrobbleViewBasic' 39 39 - ) 37 37 + hasProp(v, "$type") && 38 38 + v.$type === "app.rocksky.charts.defs#scrobbleViewBasic" 39 39 + ); 40 40 } 41 41 42 42 export function validateScrobbleViewBasic(v: unknown): ValidationResult { 43 43 - return lexicons.validate('app.rocksky.charts.defs#scrobbleViewBasic', v) 43 43 + return lexicons.validate("app.rocksky.charts.defs#scrobbleViewBasic", v); 44 44 }

+28 -28

apps/api/src/lexicon/types/app/rocksky/charts/getScrobblesChart.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyChartsDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyChartsDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did?: string 14 14 + did?: string; 15 15 /** The URI of the artist to filter by */ 16 16 - artisturi?: string 16 16 + artisturi?: string; 17 17 /** The URI of the album to filter by */ 18 18 - albumuri?: string 18 18 + albumuri?: string; 19 19 /** The URI of the track to filter by */ 20 20 - songuri?: string 20 20 + songuri?: string; 21 21 } 22 22 23 23 - export type InputSchema = undefined 24 24 - export type OutputSchema = AppRockskyChartsDefs.ChartsView 25 25 - export type HandlerInput = undefined 23 23 + export type InputSchema = undefined; 24 24 + export type OutputSchema = AppRockskyChartsDefs.ChartsView; 25 25 + export type HandlerInput = undefined; 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/dropbox/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface FileView { 10 10 /** The unique identifier of the file. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The name of the file. */ 13 13 - name?: string 13 13 + name?: string; 14 14 /** The lowercased path of the file. */ 15 15 - pathLower?: string 15 15 + pathLower?: string; 16 16 /** The display path of the file. */ 17 17 - pathDisplay?: string 17 17 + pathDisplay?: string; 18 18 /** The last modified date and time of the file on the client. */ 19 19 - clientModified?: string 19 19 + clientModified?: string; 20 20 /** The last modified date and time of the file on the server. */ 21 21 - serverModified?: string 22 22 - [k: string]: unknown 21 21 + serverModified?: string; 22 22 + [k: string]: unknown; 23 23 } 24 24 25 25 export function isFileView(v: unknown): v is FileView { 26 26 return ( 27 27 isObj(v) && 28 28 - hasProp(v, '$type') && 29 29 - v.$type === 'app.rocksky.dropbox.defs#fileView' 30 30 - ) 28 28 + hasProp(v, "$type") && 29 29 + v.$type === "app.rocksky.dropbox.defs#fileView" 30 30 + ); 31 31 } 32 32 33 33 export function validateFileView(v: unknown): ValidationResult { 34 34 - return lexicons.validate('app.rocksky.dropbox.defs#fileView', v) 34 34 + return lexicons.validate("app.rocksky.dropbox.defs#fileView", v); 35 35 } 36 36 37 37 export interface FileListView { 38 38 /** A list of files in the Dropbox. */ 39 39 - files?: FileView[] 40 40 - [k: string]: unknown 39 39 + files?: FileView[]; 40 40 + [k: string]: unknown; 41 41 } 42 42 43 43 export function isFileListView(v: unknown): v is FileListView { 44 44 return ( 45 45 isObj(v) && 46 46 - hasProp(v, '$type') && 47 47 - v.$type === 'app.rocksky.dropbox.defs#fileListView' 48 48 - ) 46 46 + hasProp(v, "$type") && 47 47 + v.$type === "app.rocksky.dropbox.defs#fileListView" 48 48 + ); 49 49 } 50 50 51 51 export function validateFileListView(v: unknown): ValidationResult { 52 52 - return lexicons.validate('app.rocksky.dropbox.defs#fileListView', v) 52 52 + return lexicons.validate("app.rocksky.dropbox.defs#fileListView", v); 53 53 } 54 54 55 55 export interface TemporaryLinkView { 56 56 /** The temporary link to access the file. */ 57 57 - link?: string 58 58 - [k: string]: unknown 57 57 + link?: string; 58 58 + [k: string]: unknown; 59 59 } 60 60 61 61 export function isTemporaryLinkView(v: unknown): v is TemporaryLinkView { 62 62 return ( 63 63 isObj(v) && 64 64 - hasProp(v, '$type') && 65 65 - v.$type === 'app.rocksky.dropbox.defs#temporaryLinkView' 66 66 - ) 64 64 + hasProp(v, "$type") && 65 65 + v.$type === "app.rocksky.dropbox.defs#temporaryLinkView" 66 66 + ); 67 67 } 68 68 69 69 export function validateTemporaryLinkView(v: unknown): ValidationResult { 70 70 - return lexicons.validate('app.rocksky.dropbox.defs#temporaryLinkView', v) 70 70 + return lexicons.validate("app.rocksky.dropbox.defs#temporaryLinkView", v); 71 71 }

+24 -24

apps/api/src/lexicon/types/app/rocksky/dropbox/downloadFile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import type stream from 'stream' 6 6 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 7 7 - import { lexicons } from '../../../../lexicons' 8 8 - import { isObj, hasProp } from '../../../../util' 9 9 - import { CID } from 'multiformats/cid' 10 10 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import stream from "stream"; 6 6 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 7 7 + import { lexicons } from "../../../../lexicons"; 8 8 + import { isObj, hasProp } from "../../../../util"; 9 9 + import { CID } from "multiformats/cid"; 10 10 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the file to download */ 14 14 - fileId: string 14 14 + fileId: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type HandlerInput = undefined; 19 19 20 20 export interface HandlerSuccess { 21 21 - encoding: 'application/octet-stream' 22 22 - body: Uint8Array | stream.Readable 23 23 - headers?: { [key: string]: string } 21 21 + encoding: "application/octet-stream"; 22 22 + body: Uint8Array | stream.Readable; 23 23 + headers?: { [key: string]: string }; 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number 28 28 - message?: string 27 27 + status: number; 28 28 + message?: string; 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA 34 34 - params: QueryParams 35 35 - input: HandlerInput 36 36 - req: express.Request 37 37 - res: express.Response 38 38 - resetRouteRateLimits: () => Promise<void> 39 39 - } 33 33 + auth: HA; 34 34 + params: QueryParams; 35 35 + input: HandlerInput; 36 36 + req: express.Request; 37 37 + res: express.Response; 38 38 + resetRouteRateLimits: () => Promise<void>; 39 39 + }; 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput 42 42 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/dropbox/getFiles.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyDropboxDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyDropboxDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** Path to the Dropbox folder or root directory */ 14 14 - at?: string 14 14 + at?: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyDropboxDefs.FileListView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyDropboxDefs.FileListView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/dropbox/getMetadata.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyDropboxDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyDropboxDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** Path to the file or folder in Dropbox */ 14 14 - path: string 14 14 + path: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyDropboxDefs.FileView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyDropboxDefs.FileView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/dropbox/getTemporaryLink.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyDropboxDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyDropboxDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** Path to the file in Dropbox */ 14 14 - path: string 14 14 + path: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyDropboxDefs.TemporaryLinkView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyDropboxDefs.TemporaryLinkView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+45 -45

apps/api/src/lexicon/types/app/rocksky/feed/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as AppRockskySongDefs from '../song/defs' 9 9 - import type * as AppRockskyAlbumDefs from '../album/defs' 10 10 - import type * as AppRockskyArtistDefs from '../artist/defs' 11 11 - import type * as AppRockskyPlaylistDefs from '../playlist/defs' 12 12 - import type * as AppRockskyActorDefs from '../actor/defs' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as AppRockskySongDefs from "../song/defs"; 9 9 + import * as AppRockskyAlbumDefs from "../album/defs"; 10 10 + import * as AppRockskyArtistDefs from "../artist/defs"; 11 11 + import * as AppRockskyPlaylistDefs from "../playlist/defs"; 12 12 + import * as AppRockskyActorDefs from "../actor/defs"; 13 13 14 14 export interface SearchResultsView { 15 15 hits?: ( ··· 19 19 | AppRockskyPlaylistDefs.PlaylistViewBasic 20 20 | AppRockskyActorDefs.ProfileViewBasic 21 21 | { $type: string; [k: string]: unknown } 22 22 - )[] 23 23 - processingTimeMs?: number 24 24 - limit?: number 25 25 - offset?: number 26 26 - estimatedTotalHits?: number 27 27 - [k: string]: unknown 22 22 + )[]; 23 23 + processingTimeMs?: number; 24 24 + limit?: number; 25 25 + offset?: number; 26 26 + estimatedTotalHits?: number; 27 27 + [k: string]: unknown; 28 28 } 29 29 30 30 export function isSearchResultsView(v: unknown): v is SearchResultsView { 31 31 return ( 32 32 isObj(v) && 33 33 - hasProp(v, '$type') && 34 34 - v.$type === 'app.rocksky.feed.defs#searchResultsView' 35 35 - ) 33 33 + hasProp(v, "$type") && 34 34 + v.$type === "app.rocksky.feed.defs#searchResultsView" 35 35 + ); 36 36 } 37 37 38 38 export function validateSearchResultsView(v: unknown): ValidationResult { 39 39 - return lexicons.validate('app.rocksky.feed.defs#searchResultsView', v) 39 39 + return lexicons.validate("app.rocksky.feed.defs#searchResultsView", v); 40 40 } 41 41 42 42 export interface NowPlayingView { 43 43 - album?: string 44 44 - albumArt?: string 45 45 - albumArtist?: string 46 46 - albumUri?: string 47 47 - artist?: string 48 48 - artistUri?: string 49 49 - avatar?: string 50 50 - createdAt?: string 51 51 - did?: string 52 52 - handle?: string 53 53 - id?: string 54 54 - title?: string 55 55 - trackId?: string 56 56 - trackUri?: string 57 57 - uri?: string 58 58 - [k: string]: unknown 43 43 + album?: string; 44 44 + albumArt?: string; 45 45 + albumArtist?: string; 46 46 + albumUri?: string; 47 47 + artist?: string; 48 48 + artistUri?: string; 49 49 + avatar?: string; 50 50 + createdAt?: string; 51 51 + did?: string; 52 52 + handle?: string; 53 53 + id?: string; 54 54 + title?: string; 55 55 + trackId?: string; 56 56 + trackUri?: string; 57 57 + uri?: string; 58 58 + [k: string]: unknown; 59 59 } 60 60 61 61 export function isNowPlayingView(v: unknown): v is NowPlayingView { 62 62 return ( 63 63 isObj(v) && 64 64 - hasProp(v, '$type') && 65 65 - v.$type === 'app.rocksky.feed.defs#nowPlayingView' 66 66 - ) 64 64 + hasProp(v, "$type") && 65 65 + v.$type === "app.rocksky.feed.defs#nowPlayingView" 66 66 + ); 67 67 } 68 68 69 69 export function validateNowPlayingView(v: unknown): ValidationResult { 70 70 - return lexicons.validate('app.rocksky.feed.defs#nowPlayingView', v) 70 70 + return lexicons.validate("app.rocksky.feed.defs#nowPlayingView", v); 71 71 } 72 72 73 73 export interface NowPlayingsView { 74 74 - nowPlayings?: NowPlayingView[] 75 75 - [k: string]: unknown 74 74 + nowPlayings?: NowPlayingView[]; 75 75 + [k: string]: unknown; 76 76 } 77 77 78 78 export function isNowPlayingsView(v: unknown): v is NowPlayingsView { 79 79 return ( 80 80 isObj(v) && 81 81 - hasProp(v, '$type') && 82 82 - v.$type === 'app.rocksky.feed.defs#nowPlayingsView' 83 83 - ) 81 81 + hasProp(v, "$type") && 82 82 + v.$type === "app.rocksky.feed.defs#nowPlayingsView" 83 83 + ); 84 84 } 85 85 86 86 export function validateNowPlayingsView(v: unknown): ValidationResult { 87 87 - return lexicons.validate('app.rocksky.feed.defs#nowPlayingsView', v) 87 87 + return lexicons.validate("app.rocksky.feed.defs#nowPlayingsView", v); 88 88 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/feed/getNowPlayings.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyFeedDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyFeedDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of now playing tracks to return. */ 14 14 - size?: number 14 14 + size?: number; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyFeedDefs.NowPlayingsView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyFeedDefs.NowPlayingsView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/feed/search.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyFeedDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyFeedDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The search query string */ 14 14 - query: string 14 14 + query: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyFeedDefs.SearchResultsView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyFeedDefs.SearchResultsView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+16 -16

apps/api/src/lexicon/types/app/rocksky/googledrive/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface FileView { 10 10 /** The unique identifier of the file. */ 11 11 - id?: string 12 12 - [k: string]: unknown 11 11 + id?: string; 12 12 + [k: string]: unknown; 13 13 } 14 14 15 15 export function isFileView(v: unknown): v is FileView { 16 16 return ( 17 17 isObj(v) && 18 18 - hasProp(v, '$type') && 19 19 - v.$type === 'app.rocksky.googledrive.defs#fileView' 20 20 - ) 18 18 + hasProp(v, "$type") && 19 19 + v.$type === "app.rocksky.googledrive.defs#fileView" 20 20 + ); 21 21 } 22 22 23 23 export function validateFileView(v: unknown): ValidationResult { 24 24 - return lexicons.validate('app.rocksky.googledrive.defs#fileView', v) 24 24 + return lexicons.validate("app.rocksky.googledrive.defs#fileView", v); 25 25 } 26 26 27 27 export interface FileListView { 28 28 - files?: FileView[] 29 29 - [k: string]: unknown 28 28 + files?: FileView[]; 29 29 + [k: string]: unknown; 30 30 } 31 31 32 32 export function isFileListView(v: unknown): v is FileListView { 33 33 return ( 34 34 isObj(v) && 35 35 - hasProp(v, '$type') && 36 36 - v.$type === 'app.rocksky.googledrive.defs#fileListView' 37 37 - ) 35 35 + hasProp(v, "$type") && 36 36 + v.$type === "app.rocksky.googledrive.defs#fileListView" 37 37 + ); 38 38 } 39 39 40 40 export function validateFileListView(v: unknown): ValidationResult { 41 41 - return lexicons.validate('app.rocksky.googledrive.defs#fileListView', v) 41 41 + return lexicons.validate("app.rocksky.googledrive.defs#fileListView", v); 42 42 }

+24 -24

apps/api/src/lexicon/types/app/rocksky/googledrive/downloadFile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import type stream from 'stream' 6 6 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 7 7 - import { lexicons } from '../../../../lexicons' 8 8 - import { isObj, hasProp } from '../../../../util' 9 9 - import { CID } from 'multiformats/cid' 10 10 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import stream from "stream"; 6 6 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 7 7 + import { lexicons } from "../../../../lexicons"; 8 8 + import { isObj, hasProp } from "../../../../util"; 9 9 + import { CID } from "multiformats/cid"; 10 10 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the file to download */ 14 14 - fileId: string 14 14 + fileId: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type HandlerInput = undefined; 19 19 20 20 export interface HandlerSuccess { 21 21 - encoding: 'application/octet-stream' 22 22 - body: Uint8Array | stream.Readable 23 23 - headers?: { [key: string]: string } 21 21 + encoding: "application/octet-stream"; 22 22 + body: Uint8Array | stream.Readable; 23 23 + headers?: { [key: string]: string }; 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number 28 28 - message?: string 27 27 + status: number; 28 28 + message?: string; 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA 34 34 - params: QueryParams 35 35 - input: HandlerInput 36 36 - req: express.Request 37 37 - res: express.Response 38 38 - resetRouteRateLimits: () => Promise<void> 39 39 - } 33 33 + auth: HA; 34 34 + params: QueryParams; 35 35 + input: HandlerInput; 36 36 + req: express.Request; 37 37 + res: express.Response; 38 38 + resetRouteRateLimits: () => Promise<void>; 39 39 + }; 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput 42 42 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/googledrive/getFile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyGoogledriveDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyGoogledriveDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the file to retrieve */ 14 14 - fileId: string 14 14 + fileId: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyGoogledriveDefs.FileView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyGoogledriveDefs.FileView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/googledrive/getFiles.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyGoogledriveDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyGoogledriveDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** Path to the Google Drive folder or root directory */ 14 14 - at?: string 14 14 + at?: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyGoogledriveDefs.FileListView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyGoogledriveDefs.FileListView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+12 -12

apps/api/src/lexicon/types/app/rocksky/like.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as ComAtprotoRepoStrongRef from "../../com/atproto/repo/strongRef"; 9 9 10 10 export interface Record { 11 11 /** The date when the like was created. */ 12 12 - createdAt: string 13 13 - subject: ComAtprotoRepoStrongRef.Main 14 14 - [k: string]: unknown 12 12 + createdAt: string; 13 13 + subject: ComAtprotoRepoStrongRef.Main; 14 14 + [k: string]: unknown; 15 15 } 16 16 17 17 export function isRecord(v: unknown): v is Record { 18 18 return ( 19 19 isObj(v) && 20 20 - hasProp(v, '$type') && 21 21 - (v.$type === 'app.rocksky.like#main' || v.$type === 'app.rocksky.like') 22 22 - ) 20 20 + hasProp(v, "$type") && 21 21 + (v.$type === "app.rocksky.like#main" || v.$type === "app.rocksky.like") 22 22 + ); 23 23 } 24 24 25 25 export function validateRecord(v: unknown): ValidationResult { 26 26 - return lexicons.validate('app.rocksky.like#main', v) 26 26 + return lexicons.validate("app.rocksky.like#main", v); 27 27 }

+27 -27

apps/api/src/lexicon/types/app/rocksky/like/dislikeShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from '../shout/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "../shout/defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the shout to dislike */ 16 16 - uri?: string 17 17 - [k: string]: unknown 16 16 + uri?: string; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 20 20 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 21 21 22 22 export interface HandlerInput { 23 23 - encoding: 'application/json' 24 24 - body: InputSchema 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 } 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/like/dislikeSong.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the song to dislike */ 16 16 - uri?: string 17 17 - [k: string]: unknown 16 16 + uri?: string; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 - export type OutputSchema = AppRockskySongDefs.SongViewDetailed 20 20 + export type OutputSchema = AppRockskySongDefs.SongViewDetailed; 21 21 22 22 export interface HandlerInput { 23 23 - encoding: 'application/json' 24 24 - body: InputSchema 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 } 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/like/likeShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from '../shout/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "../shout/defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the shout to like */ 16 16 - uri?: string 17 17 - [k: string]: unknown 16 16 + uri?: string; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 20 20 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 21 21 22 22 export interface HandlerInput { 23 23 - encoding: 'application/json' 24 24 - body: InputSchema 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 } 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/like/likeSong.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "../song/defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the song to like */ 16 16 - uri?: string 17 17 - [k: string]: unknown 16 16 + uri?: string; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 - export type OutputSchema = AppRockskySongDefs.SongViewDetailed 20 20 + export type OutputSchema = AppRockskySongDefs.SongViewDetailed; 21 21 22 22 export interface HandlerInput { 23 23 - encoding: 'application/json' 24 24 - body: InputSchema 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 } 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+23 -23

apps/api/src/lexicon/types/app/rocksky/player/addDirectoryToQueue.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 /** The directory to add to the queue */ 14 14 - directory: string 14 14 + directory: string; 15 15 /** Position in the queue to insert the directory at, defaults to the end if not specified */ 16 16 - position?: number 16 16 + position?: number; 17 17 /** Whether to shuffle the added directory in the queue */ 18 18 - shuffle?: boolean 18 18 + shuffle?: boolean; 19 19 } 20 20 21 21 - export type InputSchema = undefined 22 22 - export type HandlerInput = undefined 21 21 + export type InputSchema = undefined; 22 22 + export type HandlerInput = undefined; 23 23 24 24 export interface HandlerError { 25 25 - status: number 26 26 - message?: string 25 25 + status: number; 26 26 + message?: string; 27 27 } 28 28 29 29 - export type HandlerOutput = HandlerError | void 29 29 + export type HandlerOutput = HandlerError | void; 30 30 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 31 31 - auth: HA 32 32 - params: QueryParams 33 33 - input: HandlerInput 34 34 - req: express.Request 35 35 - res: express.Response 36 36 - resetRouteRateLimits: () => Promise<void> 37 37 - } 31 31 + auth: HA; 32 32 + params: QueryParams; 33 33 + input: HandlerInput; 34 34 + req: express.Request; 35 35 + res: express.Response; 36 36 + resetRouteRateLimits: () => Promise<void>; 37 37 + }; 38 38 export type Handler<HA extends HandlerAuth = never> = ( 39 39 ctx: HandlerReqCtx<HA>, 40 40 - ) => Promise<HandlerOutput> | HandlerOutput 40 40 + ) => Promise<HandlerOutput> | HandlerOutput;

+23 -23

apps/api/src/lexicon/types/app/rocksky/player/addItemsToQueue.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 13 13 - items: string[] 12 12 + playerId?: string; 13 13 + items: string[]; 14 14 /** Position in the queue to insert the items at, defaults to the end if not specified */ 15 15 - position?: number 15 15 + position?: number; 16 16 /** Whether to shuffle the added items in the queue */ 17 17 - shuffle?: boolean 17 17 + shuffle?: boolean; 18 18 } 19 19 20 20 - export type InputSchema = undefined 21 21 - export type HandlerInput = undefined 20 20 + export type InputSchema = undefined; 21 21 + export type HandlerInput = undefined; 22 22 23 23 export interface HandlerError { 24 24 - status: number 25 25 - message?: string 24 24 + status: number; 25 25 + message?: string; 26 26 } 27 27 28 28 - export type HandlerOutput = HandlerError | void 28 28 + export type HandlerOutput = HandlerError | void; 29 29 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA 31 31 - params: QueryParams 32 32 - input: HandlerInput 33 33 - req: express.Request 34 34 - res: express.Response 35 35 - resetRouteRateLimits: () => Promise<void> 36 36 - } 30 30 + auth: HA; 31 31 + params: QueryParams; 32 32 + input: HandlerInput; 33 33 + req: express.Request; 34 34 + res: express.Response; 35 35 + resetRouteRateLimits: () => Promise<void>; 36 36 + }; 37 37 export type Handler<HA extends HandlerAuth = never> = ( 38 38 ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput 39 39 + ) => Promise<HandlerOutput> | HandlerOutput;

+19 -19

apps/api/src/lexicon/types/app/rocksky/player/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as AppRockskySongDefsSongViewBasic from '../song/defs/songViewBasic' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as AppRockskySongDefsSongViewBasic from "../song/defs/songViewBasic"; 9 9 10 10 export interface CurrentlyPlayingViewDetailed { 11 11 /** The title of the currently playing track */ 12 12 - title?: string 13 13 - [k: string]: unknown 12 12 + title?: string; 13 13 + [k: string]: unknown; 14 14 } 15 15 16 16 export function isCurrentlyPlayingViewDetailed( ··· 18 18 ): v is CurrentlyPlayingViewDetailed { 19 19 return ( 20 20 isObj(v) && 21 21 - hasProp(v, '$type') && 22 22 - v.$type === 'app.rocksky.player.defs#currentlyPlayingViewDetailed' 23 23 - ) 21 21 + hasProp(v, "$type") && 22 22 + v.$type === "app.rocksky.player.defs#currentlyPlayingViewDetailed" 23 23 + ); 24 24 } 25 25 26 26 export function validateCurrentlyPlayingViewDetailed( 27 27 v: unknown, 28 28 ): ValidationResult { 29 29 return lexicons.validate( 30 30 - 'app.rocksky.player.defs#currentlyPlayingViewDetailed', 30 30 + "app.rocksky.player.defs#currentlyPlayingViewDetailed", 31 31 v, 32 32 - ) 32 32 + ); 33 33 } 34 34 35 35 export interface PlaybackQueueViewDetailed { 36 36 - tracks?: AppRockskySongDefsSongViewBasic.Main[] 37 37 - [k: string]: unknown 36 36 + tracks?: AppRockskySongDefsSongViewBasic.Main[]; 37 37 + [k: string]: unknown; 38 38 } 39 39 40 40 export function isPlaybackQueueViewDetailed( ··· 42 42 ): v is PlaybackQueueViewDetailed { 43 43 return ( 44 44 isObj(v) && 45 45 - hasProp(v, '$type') && 46 46 - v.$type === 'app.rocksky.player.defs#playbackQueueViewDetailed' 47 47 - ) 45 45 + hasProp(v, "$type") && 46 46 + v.$type === "app.rocksky.player.defs#playbackQueueViewDetailed" 47 47 + ); 48 48 } 49 49 50 50 export function validatePlaybackQueueViewDetailed( 51 51 v: unknown, 52 52 ): ValidationResult { 53 53 return lexicons.validate( 54 54 - 'app.rocksky.player.defs#playbackQueueViewDetailed', 54 54 + "app.rocksky.player.defs#playbackQueueViewDetailed", 55 55 v, 56 56 - ) 56 56 + ); 57 57 }

+26 -26

apps/api/src/lexicon/types/app/rocksky/player/getCurrentlyPlaying.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlayerDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlayerDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 - playerId?: string 13 13 + playerId?: string; 14 14 /** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */ 15 15 - actor?: string 15 15 + actor?: string; 16 16 } 17 17 18 18 - export type InputSchema = undefined 19 19 - export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed 20 20 - export type HandlerInput = undefined 18 18 + export type InputSchema = undefined; 19 19 + export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed; 20 20 + export type HandlerInput = undefined; 21 21 22 22 export interface HandlerSuccess { 23 23 - encoding: 'application/json' 24 24 - body: OutputSchema 25 25 - headers?: { [key: string]: string } 23 23 + encoding: "application/json"; 24 24 + body: OutputSchema; 25 25 + headers?: { [key: string]: string }; 26 26 } 27 27 28 28 export interface HandlerError { 29 29 - status: number 30 30 - message?: string 29 29 + status: number; 30 30 + message?: string; 31 31 } 32 32 33 33 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 34 34 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 35 35 - auth: HA 36 36 - params: QueryParams 37 37 - input: HandlerInput 38 38 - req: express.Request 39 39 - res: express.Response 40 40 - resetRouteRateLimits: () => Promise<void> 41 41 - } 35 35 + auth: HA; 36 36 + params: QueryParams; 37 37 + input: HandlerInput; 38 38 + req: express.Request; 39 39 + res: express.Response; 40 40 + resetRouteRateLimits: () => Promise<void>; 41 41 + }; 42 42 export type Handler<HA extends HandlerAuth = never> = ( 43 43 ctx: HandlerReqCtx<HA>, 44 44 - ) => Promise<HandlerOutput> | HandlerOutput 44 44 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/player/getPlaybackQueue.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlayerDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlayerDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 - playerId?: string 13 13 + playerId?: string; 14 14 } 15 15 16 16 - export type InputSchema = undefined 17 17 - export type OutputSchema = AppRockskyPlayerDefs.PlaybackQueueViewDetailed 18 18 - export type HandlerInput = undefined 16 16 + export type InputSchema = undefined; 17 17 + export type OutputSchema = AppRockskyPlayerDefs.PlaybackQueueViewDetailed; 18 18 + export type HandlerInput = undefined; 19 19 20 20 export interface HandlerSuccess { 21 21 - encoding: 'application/json' 22 22 - body: OutputSchema 23 23 - headers?: { [key: string]: string } 21 21 + encoding: "application/json"; 22 22 + body: OutputSchema; 23 23 + headers?: { [key: string]: string }; 24 24 } 25 25 26 26 export interface HandlerError { 27 27 - status: number 28 28 - message?: string 27 27 + status: number; 28 28 + message?: string; 29 29 } 30 30 31 31 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 32 32 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 33 33 - auth: HA 34 34 - params: QueryParams 35 35 - input: HandlerInput 36 36 - req: express.Request 37 37 - res: express.Response 38 38 - resetRouteRateLimits: () => Promise<void> 39 39 - } 33 33 + auth: HA; 34 34 + params: QueryParams; 35 35 + input: HandlerInput; 36 36 + req: express.Request; 37 37 + res: express.Response; 38 38 + resetRouteRateLimits: () => Promise<void>; 39 39 + }; 40 40 export type Handler<HA extends HandlerAuth = never> = ( 41 41 ctx: HandlerReqCtx<HA>, 42 42 - ) => Promise<HandlerOutput> | HandlerOutput 42 42 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/player/next.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 } 14 14 15 15 - export type InputSchema = undefined 16 16 - export type HandlerInput = undefined 15 15 + export type InputSchema = undefined; 16 16 + export type HandlerInput = undefined; 17 17 18 18 export interface HandlerError { 19 19 - status: number 20 20 - message?: string 19 19 + status: number; 20 20 + message?: string; 21 21 } 22 22 23 23 - export type HandlerOutput = HandlerError | void 23 23 + export type HandlerOutput = HandlerError | void; 24 24 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 25 25 - auth: HA 26 26 - params: QueryParams 27 27 - input: HandlerInput 28 28 - req: express.Request 29 29 - res: express.Response 30 30 - resetRouteRateLimits: () => Promise<void> 31 31 - } 25 25 + auth: HA; 26 26 + params: QueryParams; 27 27 + input: HandlerInput; 28 28 + req: express.Request; 29 29 + res: express.Response; 30 30 + resetRouteRateLimits: () => Promise<void>; 31 31 + }; 32 32 export type Handler<HA extends HandlerAuth = never> = ( 33 33 ctx: HandlerReqCtx<HA>, 34 34 - ) => Promise<HandlerOutput> | HandlerOutput 34 34 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/player/pause.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 } 14 14 15 15 - export type InputSchema = undefined 16 16 - export type HandlerInput = undefined 15 15 + export type InputSchema = undefined; 16 16 + export type HandlerInput = undefined; 17 17 18 18 export interface HandlerError { 19 19 - status: number 20 20 - message?: string 19 19 + status: number; 20 20 + message?: string; 21 21 } 22 22 23 23 - export type HandlerOutput = HandlerError | void 23 23 + export type HandlerOutput = HandlerError | void; 24 24 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 25 25 - auth: HA 26 26 - params: QueryParams 27 27 - input: HandlerInput 28 28 - req: express.Request 29 29 - res: express.Response 30 30 - resetRouteRateLimits: () => Promise<void> 31 31 - } 25 25 + auth: HA; 26 26 + params: QueryParams; 27 27 + input: HandlerInput; 28 28 + req: express.Request; 29 29 + res: express.Response; 30 30 + resetRouteRateLimits: () => Promise<void>; 31 31 + }; 32 32 export type Handler<HA extends HandlerAuth = never> = ( 33 33 ctx: HandlerReqCtx<HA>, 34 34 - ) => Promise<HandlerOutput> | HandlerOutput 34 34 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/player/play.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 } 14 14 15 15 - export type InputSchema = undefined 16 16 - export type HandlerInput = undefined 15 15 + export type InputSchema = undefined; 16 16 + export type HandlerInput = undefined; 17 17 18 18 export interface HandlerError { 19 19 - status: number 20 20 - message?: string 19 19 + status: number; 20 20 + message?: string; 21 21 } 22 22 23 23 - export type HandlerOutput = HandlerError | void 23 23 + export type HandlerOutput = HandlerError | void; 24 24 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 25 25 - auth: HA 26 26 - params: QueryParams 27 27 - input: HandlerInput 28 28 - req: express.Request 29 29 - res: express.Response 30 30 - resetRouteRateLimits: () => Promise<void> 31 31 - } 25 25 + auth: HA; 26 26 + params: QueryParams; 27 27 + input: HandlerInput; 28 28 + req: express.Request; 29 29 + res: express.Response; 30 30 + resetRouteRateLimits: () => Promise<void>; 31 31 + }; 32 32 export type Handler<HA extends HandlerAuth = never> = ( 33 33 ctx: HandlerReqCtx<HA>, 34 34 - ) => Promise<HandlerOutput> | HandlerOutput 34 34 + ) => Promise<HandlerOutput> | HandlerOutput;

+24 -24

apps/api/src/lexicon/types/app/rocksky/player/playDirectory.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 13 13 - directoryId: string 14 14 - shuffle?: boolean 15 15 - recurse?: boolean 16 16 - position?: number 12 12 + playerId?: string; 13 13 + directoryId: string; 14 14 + shuffle?: boolean; 15 15 + recurse?: boolean; 16 16 + position?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 20 20 - export type HandlerInput = undefined 19 19 + export type InputSchema = undefined; 20 20 + export type HandlerInput = undefined; 21 21 22 22 export interface HandlerError { 23 23 - status: number 24 24 - message?: string 23 23 + status: number; 24 24 + message?: string; 25 25 } 26 26 27 27 - export type HandlerOutput = HandlerError | void 27 27 + export type HandlerOutput = HandlerError | void; 28 28 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA 30 30 - params: QueryParams 31 31 - input: HandlerInput 32 32 - req: express.Request 33 33 - res: express.Response 34 34 - resetRouteRateLimits: () => Promise<void> 35 35 - } 29 29 + auth: HA; 30 30 + params: QueryParams; 31 31 + input: HandlerInput; 32 32 + req: express.Request; 33 33 + res: express.Response; 34 34 + resetRouteRateLimits: () => Promise<void>; 35 35 + }; 36 36 export type Handler<HA extends HandlerAuth = never> = ( 37 37 ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput 38 38 + ) => Promise<HandlerOutput> | HandlerOutput;

+21 -21

apps/api/src/lexicon/types/app/rocksky/player/playFile.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 13 13 - fileId: string 12 12 + playerId?: string; 13 13 + fileId: string; 14 14 } 15 15 16 16 - export type InputSchema = undefined 17 17 - export type HandlerInput = undefined 16 16 + export type InputSchema = undefined; 17 17 + export type HandlerInput = undefined; 18 18 19 19 export interface HandlerError { 20 20 - status: number 21 21 - message?: string 20 20 + status: number; 21 21 + message?: string; 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void 24 24 + export type HandlerOutput = HandlerError | void; 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA 27 27 - params: QueryParams 28 28 - input: HandlerInput 29 29 - req: express.Request 30 30 - res: express.Response 31 31 - resetRouteRateLimits: () => Promise<void> 32 32 - } 26 26 + auth: HA; 27 27 + params: QueryParams; 28 28 + input: HandlerInput; 29 29 + req: express.Request; 30 30 + res: express.Response; 31 31 + resetRouteRateLimits: () => Promise<void>; 32 32 + }; 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput 35 35 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/player/previous.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 } 14 14 15 15 - export type InputSchema = undefined 16 16 - export type HandlerInput = undefined 15 15 + export type InputSchema = undefined; 16 16 + export type HandlerInput = undefined; 17 17 18 18 export interface HandlerError { 19 19 - status: number 20 20 - message?: string 19 19 + status: number; 20 20 + message?: string; 21 21 } 22 22 23 23 - export type HandlerOutput = HandlerError | void 23 23 + export type HandlerOutput = HandlerError | void; 24 24 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 25 25 - auth: HA 26 26 - params: QueryParams 27 27 - input: HandlerInput 28 28 - req: express.Request 29 29 - res: express.Response 30 30 - resetRouteRateLimits: () => Promise<void> 31 31 - } 25 25 + auth: HA; 26 26 + params: QueryParams; 27 27 + input: HandlerInput; 28 28 + req: express.Request; 29 29 + res: express.Response; 30 30 + resetRouteRateLimits: () => Promise<void>; 31 31 + }; 32 32 export type Handler<HA extends HandlerAuth = never> = ( 33 33 ctx: HandlerReqCtx<HA>, 34 34 - ) => Promise<HandlerOutput> | HandlerOutput 34 34 + ) => Promise<HandlerOutput> | HandlerOutput;

+21 -21

apps/api/src/lexicon/types/app/rocksky/player/seek.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 - playerId?: string 12 12 + playerId?: string; 13 13 /** The position in seconds to seek to */ 14 14 - position: number 14 14 + position: number; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type HandlerInput = undefined; 19 19 20 20 export interface HandlerError { 21 21 - status: number 22 22 - message?: string 21 21 + status: number; 22 22 + message?: string; 23 23 } 24 24 25 25 - export type HandlerOutput = HandlerError | void 25 25 + export type HandlerOutput = HandlerError | void; 26 26 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 27 27 - auth: HA 28 28 - params: QueryParams 29 29 - input: HandlerInput 30 30 - req: express.Request 31 31 - res: express.Response 32 32 - resetRouteRateLimits: () => Promise<void> 33 33 - } 27 27 + auth: HA; 28 28 + params: QueryParams; 29 29 + input: HandlerInput; 30 30 + req: express.Request; 31 31 + res: express.Response; 32 32 + resetRouteRateLimits: () => Promise<void>; 33 33 + }; 34 34 export type Handler<HA extends HandlerAuth = never> = ( 35 35 ctx: HandlerReqCtx<HA>, 36 36 - ) => Promise<HandlerOutput> | HandlerOutput 36 36 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/playlist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as AppRockskySong from './song' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as AppRockskySong from "./song"; 9 9 10 10 export interface Record { 11 11 /** The name of the playlist. */ 12 12 - name: string 12 12 + name: string; 13 13 /** The playlist description. */ 14 14 - description?: string 14 14 + description?: string; 15 15 /** The picture of the playlist. */ 16 16 - picture?: BlobRef 16 16 + picture?: BlobRef; 17 17 /** The tracks in the playlist. */ 18 18 - tracks?: AppRockskySong.Record[] 18 18 + tracks?: AppRockskySong.Record[]; 19 19 /** The date the playlist was created. */ 20 20 - createdAt: string 20 20 + createdAt: string; 21 21 /** The Spotify link of the playlist. */ 22 22 - spotifyLink?: string 22 22 + spotifyLink?: string; 23 23 /** The Tidal link of the playlist. */ 24 24 - tidalLink?: string 24 24 + tidalLink?: string; 25 25 /** The YouTube link of the playlist. */ 26 26 - youtubeLink?: string 26 26 + youtubeLink?: string; 27 27 /** The Apple Music link of the playlist. */ 28 28 - appleMusicLink?: string 29 29 - [k: string]: unknown 28 28 + appleMusicLink?: string; 29 29 + [k: string]: unknown; 30 30 } 31 31 32 32 export function isRecord(v: unknown): v is Record { 33 33 return ( 34 34 isObj(v) && 35 35 - hasProp(v, '$type') && 36 36 - (v.$type === 'app.rocksky.playlist#main' || 37 37 - v.$type === 'app.rocksky.playlist') 38 38 - ) 35 35 + hasProp(v, "$type") && 36 36 + (v.$type === "app.rocksky.playlist#main" || 37 37 + v.$type === "app.rocksky.playlist") 38 38 + ); 39 39 } 40 40 41 41 export function validateRecord(v: unknown): ValidationResult { 42 42 - return lexicons.validate('app.rocksky.playlist#main', v) 42 42 + return lexicons.validate("app.rocksky.playlist#main", v); 43 43 }

+21 -21

apps/api/src/lexicon/types/app/rocksky/playlist/createPlaylist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The name of the playlist */ 13 13 - name: string 13 13 + name: string; 14 14 /** A brief description of the playlist */ 15 15 - description?: string 15 15 + description?: string; 16 16 } 17 17 18 18 - export type InputSchema = undefined 19 19 - export type HandlerInput = undefined 18 18 + export type InputSchema = undefined; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerError { 22 22 - status: number 23 23 - message?: string 22 22 + status: number; 23 23 + message?: string; 24 24 } 25 25 26 26 - export type HandlerOutput = HandlerError | void 26 26 + export type HandlerOutput = HandlerError | void; 27 27 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA 29 29 - params: QueryParams 30 30 - input: HandlerInput 31 31 - req: express.Request 32 32 - res: express.Response 33 33 - resetRouteRateLimits: () => Promise<void> 34 34 - } 28 28 + auth: HA; 29 29 + params: QueryParams; 30 30 + input: HandlerInput; 31 31 + req: express.Request; 32 32 + res: express.Response; 33 33 + resetRouteRateLimits: () => Promise<void>; 34 34 + }; 35 35 export type Handler<HA extends HandlerAuth = never> = ( 36 36 ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput 37 37 + ) => Promise<HandlerOutput> | HandlerOutput;

+37 -37

apps/api/src/lexicon/types/app/rocksky/playlist/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as AppRockskySongDefs from '../song/defs' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as AppRockskySongDefs from "../song/defs"; 9 9 10 10 /** Detailed view of a playlist, including its tracks and metadata */ 11 11 export interface PlaylistViewDetailed { 12 12 /** The unique identifier of the playlist. */ 13 13 - id?: string 13 13 + id?: string; 14 14 /** The title of the playlist. */ 15 15 - title?: string 15 15 + title?: string; 16 16 /** The URI of the playlist. */ 17 17 - uri?: string 17 17 + uri?: string; 18 18 /** The DID of the curator of the playlist. */ 19 19 - curatorDid?: string 19 19 + curatorDid?: string; 20 20 /** The handle of the curator of the playlist. */ 21 21 - curatorHandle?: string 21 21 + curatorHandle?: string; 22 22 /** The name of the curator of the playlist. */ 23 23 - curatorName?: string 23 23 + curatorName?: string; 24 24 /** The URL of the avatar image of the curator. */ 25 25 - curatorAvatarUrl?: string 25 25 + curatorAvatarUrl?: string; 26 26 /** A description of the playlist. */ 27 27 - description?: string 27 27 + description?: string; 28 28 /** The URL of the cover image for the playlist. */ 29 29 - coverImageUrl?: string 29 29 + coverImageUrl?: string; 30 30 /** The date and time when the playlist was created. */ 31 31 - createdAt?: string 31 31 + createdAt?: string; 32 32 /** A list of tracks in the playlist. */ 33 33 - tracks?: AppRockskySongDefs.SongViewBasic[] 34 34 - [k: string]: unknown 33 33 + tracks?: AppRockskySongDefs.SongViewBasic[]; 34 34 + [k: string]: unknown; 35 35 } 36 36 37 37 export function isPlaylistViewDetailed(v: unknown): v is PlaylistViewDetailed { 38 38 return ( 39 39 isObj(v) && 40 40 - hasProp(v, '$type') && 41 41 - v.$type === 'app.rocksky.playlist.defs#playlistViewDetailed' 42 42 - ) 40 40 + hasProp(v, "$type") && 41 41 + v.$type === "app.rocksky.playlist.defs#playlistViewDetailed" 42 42 + ); 43 43 } 44 44 45 45 export function validatePlaylistViewDetailed(v: unknown): ValidationResult { 46 46 - return lexicons.validate('app.rocksky.playlist.defs#playlistViewDetailed', v) 46 46 + return lexicons.validate("app.rocksky.playlist.defs#playlistViewDetailed", v); 47 47 } 48 48 49 49 /** Basic view of a playlist, including its metadata */ 50 50 export interface PlaylistViewBasic { 51 51 /** The unique identifier of the playlist. */ 52 52 - id?: string 52 52 + id?: string; 53 53 /** The title of the playlist. */ 54 54 - title?: string 54 54 + title?: string; 55 55 /** The URI of the playlist. */ 56 56 - uri?: string 56 56 + uri?: string; 57 57 /** The DID of the curator of the playlist. */ 58 58 - curatorDid?: string 58 58 + curatorDid?: string; 59 59 /** The handle of the curator of the playlist. */ 60 60 - curatorHandle?: string 60 60 + curatorHandle?: string; 61 61 /** The name of the curator of the playlist. */ 62 62 - curatorName?: string 62 62 + curatorName?: string; 63 63 /** The URL of the avatar image of the curator. */ 64 64 - curatorAvatarUrl?: string 64 64 + curatorAvatarUrl?: string; 65 65 /** A description of the playlist. */ 66 66 - description?: string 66 66 + description?: string; 67 67 /** The URL of the cover image for the playlist. */ 68 68 - coverImageUrl?: string 68 68 + coverImageUrl?: string; 69 69 /** The date and time when the playlist was created. */ 70 70 - createdAt?: string 70 70 + createdAt?: string; 71 71 /** The number of tracks in the playlist. */ 72 72 - trackCount?: number 73 73 - [k: string]: unknown 72 72 + trackCount?: number; 73 73 + [k: string]: unknown; 74 74 } 75 75 76 76 export function isPlaylistViewBasic(v: unknown): v is PlaylistViewBasic { 77 77 return ( 78 78 isObj(v) && 79 79 - hasProp(v, '$type') && 80 80 - v.$type === 'app.rocksky.playlist.defs#playlistViewBasic' 81 81 - ) 79 79 + hasProp(v, "$type") && 80 80 + v.$type === "app.rocksky.playlist.defs#playlistViewBasic" 81 81 + ); 82 82 } 83 83 84 84 export function validatePlaylistViewBasic(v: unknown): ValidationResult { 85 85 - return lexicons.validate('app.rocksky.playlist.defs#playlistViewBasic', v) 85 85 + return lexicons.validate("app.rocksky.playlist.defs#playlistViewBasic", v); 86 86 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/playlist/getPlaylist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlaylistDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlaylistDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the playlist to retrieve. */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyPlaylistDefs.PlaylistViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyPlaylistDefs.PlaylistViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/playlist/getPlaylists.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlaylistDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlaylistDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of playlists to return. */ 14 14 - limit?: number 14 14 + limit?: number; 15 15 /** The offset for pagination, used to skip a number of playlists. */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 19 19 + export type InputSchema = undefined; 20 20 21 21 export interface OutputSchema { 22 22 - playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[] 23 23 - [k: string]: unknown 22 22 + playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]; 23 23 + [k: string]: unknown; 24 24 } 25 25 26 26 - export type HandlerInput = undefined 26 26 + export type HandlerInput = undefined; 27 27 28 28 export interface HandlerSuccess { 29 29 - encoding: 'application/json' 30 30 - body: OutputSchema 31 31 - headers?: { [key: string]: string } 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 } 33 33 34 34 export interface HandlerError { 35 35 - status: number 36 36 - message?: string 35 35 + status: number; 36 36 + message?: string; 37 37 } 38 38 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA 42 42 - params: QueryParams 43 43 - input: HandlerInput 44 44 - req: express.Request 45 45 - res: express.Response 46 46 - resetRouteRateLimits: () => Promise<void> 47 47 - } 41 41 + auth: HA; 42 42 + params: QueryParams; 43 43 + input: HandlerInput; 44 44 + req: express.Request; 45 45 + res: express.Response; 46 46 + resetRouteRateLimits: () => Promise<void>; 47 47 + }; 48 48 export type Handler<HA extends HandlerAuth = never> = ( 49 49 ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput 50 50 + ) => Promise<HandlerOutput> | HandlerOutput;

+22 -22

apps/api/src/lexicon/types/app/rocksky/playlist/insertDirectory.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The URI of the playlist to start */ 13 13 - uri: string 13 13 + uri: string; 14 14 /** The directory (id) to insert into the playlist */ 15 15 - directory: string 15 15 + directory: string; 16 16 /** The position in the playlist to insert the directory at, if not specified, the directory will be appended */ 17 17 - position?: number 17 17 + position?: number; 18 18 } 19 19 20 20 - export type InputSchema = undefined 21 21 - export type HandlerInput = undefined 20 20 + export type InputSchema = undefined; 21 21 + export type HandlerInput = undefined; 22 22 23 23 export interface HandlerError { 24 24 - status: number 25 25 - message?: string 24 24 + status: number; 25 25 + message?: string; 26 26 } 27 27 28 28 - export type HandlerOutput = HandlerError | void 28 28 + export type HandlerOutput = HandlerError | void; 29 29 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA 31 31 - params: QueryParams 32 32 - input: HandlerInput 33 33 - req: express.Request 34 34 - res: express.Response 35 35 - resetRouteRateLimits: () => Promise<void> 36 36 - } 30 30 + auth: HA; 31 31 + params: QueryParams; 32 32 + input: HandlerInput; 33 33 + req: express.Request; 34 34 + res: express.Response; 35 35 + resetRouteRateLimits: () => Promise<void>; 36 36 + }; 37 37 export type Handler<HA extends HandlerAuth = never> = ( 38 38 ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput 39 39 + ) => Promise<HandlerOutput> | HandlerOutput;

+22 -22

apps/api/src/lexicon/types/app/rocksky/playlist/insertFiles.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The URI of the playlist to start */ 13 13 - uri: string 14 14 - files: string[] 13 13 + uri: string; 14 14 + files: string[]; 15 15 /** The position in the playlist to insert the files at, if not specified, files will be appended */ 16 16 - position?: number 16 16 + position?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 20 20 - export type HandlerInput = undefined 19 19 + export type InputSchema = undefined; 20 20 + export type HandlerInput = undefined; 21 21 22 22 export interface HandlerError { 23 23 - status: number 24 24 - message?: string 23 23 + status: number; 24 24 + message?: string; 25 25 } 26 26 27 27 - export type HandlerOutput = HandlerError | void 27 27 + export type HandlerOutput = HandlerError | void; 28 28 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 29 29 - auth: HA 30 30 - params: QueryParams 31 31 - input: HandlerInput 32 32 - req: express.Request 33 33 - res: express.Response 34 34 - resetRouteRateLimits: () => Promise<void> 35 35 - } 29 29 + auth: HA; 30 30 + params: QueryParams; 31 31 + input: HandlerInput; 32 32 + req: express.Request; 33 33 + res: express.Response; 34 34 + resetRouteRateLimits: () => Promise<void>; 35 35 + }; 36 36 export type Handler<HA extends HandlerAuth = never> = ( 37 37 ctx: HandlerReqCtx<HA>, 38 38 - ) => Promise<HandlerOutput> | HandlerOutput 38 38 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/playlist/removePlaylist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The URI of the playlist to remove */ 13 13 - uri: string 13 13 + uri: string; 14 14 } 15 15 16 16 - export type InputSchema = undefined 17 17 - export type HandlerInput = undefined 16 16 + export type InputSchema = undefined; 17 17 + export type HandlerInput = undefined; 18 18 19 19 export interface HandlerError { 20 20 - status: number 21 21 - message?: string 20 20 + status: number; 21 21 + message?: string; 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void 24 24 + export type HandlerOutput = HandlerError | void; 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA 27 27 - params: QueryParams 28 28 - input: HandlerInput 29 29 - req: express.Request 30 30 - res: express.Response 31 31 - resetRouteRateLimits: () => Promise<void> 32 32 - } 26 26 + auth: HA; 27 27 + params: QueryParams; 28 28 + input: HandlerInput; 29 29 + req: express.Request; 30 30 + res: express.Response; 31 31 + resetRouteRateLimits: () => Promise<void>; 32 32 + }; 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput 35 35 + ) => Promise<HandlerOutput> | HandlerOutput;

+21 -21

apps/api/src/lexicon/types/app/rocksky/playlist/removeTrack.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The URI of the playlist to remove the track from */ 13 13 - uri: string 13 13 + uri: string; 14 14 /** The position of the track to remove in the playlist */ 15 15 - position: number 15 15 + position: number; 16 16 } 17 17 18 18 - export type InputSchema = undefined 19 19 - export type HandlerInput = undefined 18 18 + export type InputSchema = undefined; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerError { 22 22 - status: number 23 23 - message?: string 22 22 + status: number; 23 23 + message?: string; 24 24 } 25 25 26 26 - export type HandlerOutput = HandlerError | void 26 26 + export type HandlerOutput = HandlerError | void; 27 27 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 28 28 - auth: HA 29 29 - params: QueryParams 30 30 - input: HandlerInput 31 31 - req: express.Request 32 32 - res: express.Response 33 33 - resetRouteRateLimits: () => Promise<void> 34 34 - } 28 28 + auth: HA; 29 29 + params: QueryParams; 30 30 + input: HandlerInput; 31 31 + req: express.Request; 32 32 + res: express.Response; 33 33 + resetRouteRateLimits: () => Promise<void>; 34 34 + }; 35 35 export type Handler<HA extends HandlerAuth = never> = ( 36 36 ctx: HandlerReqCtx<HA>, 37 37 - ) => Promise<HandlerOutput> | HandlerOutput 37 37 + ) => Promise<HandlerOutput> | HandlerOutput;

+22 -22

apps/api/src/lexicon/types/app/rocksky/playlist/startPlaylist.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The URI of the playlist to start */ 13 13 - uri: string 13 13 + uri: string; 14 14 /** Whether to shuffle the playlist when starting it */ 15 15 - shuffle?: boolean 15 15 + shuffle?: boolean; 16 16 /** The position in the playlist to start from, if not specified, starts from the beginning */ 17 17 - position?: number 17 17 + position?: number; 18 18 } 19 19 20 20 - export type InputSchema = undefined 21 21 - export type HandlerInput = undefined 20 20 + export type InputSchema = undefined; 21 21 + export type HandlerInput = undefined; 22 22 23 23 export interface HandlerError { 24 24 - status: number 25 25 - message?: string 24 24 + status: number; 25 25 + message?: string; 26 26 } 27 27 28 28 - export type HandlerOutput = HandlerError | void 28 28 + export type HandlerOutput = HandlerError | void; 29 29 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 30 30 - auth: HA 31 31 - params: QueryParams 32 32 - input: HandlerInput 33 33 - req: express.Request 34 34 - res: express.Response 35 35 - resetRouteRateLimits: () => Promise<void> 36 36 - } 30 30 + auth: HA; 31 31 + params: QueryParams; 32 32 + input: HandlerInput; 33 33 + req: express.Request; 34 34 + res: express.Response; 35 35 + resetRouteRateLimits: () => Promise<void>; 36 36 + }; 37 37 export type Handler<HA extends HandlerAuth = never> = ( 38 38 ctx: HandlerReqCtx<HA>, 39 39 - ) => Promise<HandlerOutput> | HandlerOutput 39 39 + ) => Promise<HandlerOutput> | HandlerOutput;

+16 -16

apps/api/src/lexicon/types/app/rocksky/radio.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Record { 10 10 /** The name of the radio station. */ 11 11 - name: string 11 11 + name: string; 12 12 /** The URL of the radio station. */ 13 13 - url: string 13 13 + url: string; 14 14 /** A description of the radio station. */ 15 15 - description?: string 15 15 + description?: string; 16 16 /** The genre of the radio station. */ 17 17 - genre?: string 17 17 + genre?: string; 18 18 /** The logo of the radio station. */ 19 19 - logo?: BlobRef 19 19 + logo?: BlobRef; 20 20 /** The website of the radio station. */ 21 21 - website?: string 21 21 + website?: string; 22 22 /** The date when the radio station was created. */ 23 23 - createdAt: string 24 24 - [k: string]: unknown 23 23 + createdAt: string; 24 24 + [k: string]: unknown; 25 25 } 26 26 27 27 export function isRecord(v: unknown): v is Record { 28 28 return ( 29 29 isObj(v) && 30 30 - hasProp(v, '$type') && 31 31 - (v.$type === 'app.rocksky.radio#main' || v.$type === 'app.rocksky.radio') 32 32 - ) 30 30 + hasProp(v, "$type") && 31 31 + (v.$type === "app.rocksky.radio#main" || v.$type === "app.rocksky.radio") 32 32 + ); 33 33 } 34 34 35 35 export function validateRecord(v: unknown): ValidationResult { 36 36 - return lexicons.validate('app.rocksky.radio#main', v) 36 36 + return lexicons.validate("app.rocksky.radio#main", v); 37 37 }

+26 -26

apps/api/src/lexicon/types/app/rocksky/radio/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface RadioViewBasic { 10 10 /** The unique identifier of the radio. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The name of the radio. */ 13 13 - name?: string 13 13 + name?: string; 14 14 /** A brief description of the radio. */ 15 15 - description?: string 15 15 + description?: string; 16 16 /** The date and time when the radio was created. */ 17 17 - createdAt?: string 18 18 - [k: string]: unknown 17 17 + createdAt?: string; 18 18 + [k: string]: unknown; 19 19 } 20 20 21 21 export function isRadioViewBasic(v: unknown): v is RadioViewBasic { 22 22 return ( 23 23 isObj(v) && 24 24 - hasProp(v, '$type') && 25 25 - v.$type === 'app.rocksky.radio.defs#radioViewBasic' 26 26 - ) 24 24 + hasProp(v, "$type") && 25 25 + v.$type === "app.rocksky.radio.defs#radioViewBasic" 26 26 + ); 27 27 } 28 28 29 29 export function validateRadioViewBasic(v: unknown): ValidationResult { 30 30 - return lexicons.validate('app.rocksky.radio.defs#radioViewBasic', v) 30 30 + return lexicons.validate("app.rocksky.radio.defs#radioViewBasic", v); 31 31 } 32 32 33 33 export interface RadioViewDetailed { 34 34 /** The unique identifier of the radio. */ 35 35 - id?: string 35 35 + id?: string; 36 36 /** The name of the radio. */ 37 37 - name?: string 37 37 + name?: string; 38 38 /** A brief description of the radio. */ 39 39 - description?: string 39 39 + description?: string; 40 40 /** The website of the radio. */ 41 41 - website?: string 41 41 + website?: string; 42 42 /** The streaming URL of the radio. */ 43 43 - url?: string 43 43 + url?: string; 44 44 /** The genre of the radio. */ 45 45 - genre?: string 45 45 + genre?: string; 46 46 /** The logo of the radio station. */ 47 47 - logo?: string 47 47 + logo?: string; 48 48 /** The date and time when the radio was created. */ 49 49 - createdAt?: string 50 50 - [k: string]: unknown 49 49 + createdAt?: string; 50 50 + [k: string]: unknown; 51 51 } 52 52 53 53 export function isRadioViewDetailed(v: unknown): v is RadioViewDetailed { 54 54 return ( 55 55 isObj(v) && 56 56 - hasProp(v, '$type') && 57 57 - v.$type === 'app.rocksky.radio.defs#radioViewDetailed' 58 58 - ) 56 56 + hasProp(v, "$type") && 57 57 + v.$type === "app.rocksky.radio.defs#radioViewDetailed" 58 58 + ); 59 59 } 60 60 61 61 export function validateRadioViewDetailed(v: unknown): ValidationResult { 62 62 - return lexicons.validate('app.rocksky.radio.defs#radioViewDetailed', v) 62 62 + return lexicons.validate("app.rocksky.radio.defs#radioViewDetailed", v); 63 63 }

+35 -33

apps/api/src/lexicon/types/app/rocksky/scrobble.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Record { 10 10 /** The title of the song. */ 11 11 - title: string 11 11 + title: string; 12 12 /** The artist of the song. */ 13 13 - artist: string 13 13 + artist: string; 14 14 /** The album artist of the song. */ 15 15 - albumArtist: string 15 15 + albumArtist: string; 16 16 /** The album of the song. */ 17 17 - album: string 17 17 + album: string; 18 18 /** The duration of the song in seconds. */ 19 19 - duration: number 19 19 + duration: number; 20 20 /** The track number of the song in the album. */ 21 21 - trackNumber?: number 21 21 + trackNumber?: number; 22 22 /** The disc number of the song in the album. */ 23 23 - discNumber?: number 23 23 + discNumber?: number; 24 24 /** The release date of the song. */ 25 25 - releaseDate?: string 25 25 + releaseDate?: string; 26 26 /** The year the song was released. */ 27 27 - year?: number 27 27 + year?: number; 28 28 /** The genre of the song. */ 29 29 - genre?: string 29 29 + genre?: string; 30 30 /** The tags of the song. */ 31 31 - tags?: string[] 31 31 + tags?: string[]; 32 32 /** The composer of the song. */ 33 33 - composer?: string 33 33 + composer?: string; 34 34 /** The lyrics of the song. */ 35 35 - lyrics?: string 35 35 + lyrics?: string; 36 36 /** The copyright message of the song. */ 37 37 - copyrightMessage?: string 37 37 + copyrightMessage?: string; 38 38 /** Informations about the song */ 39 39 - wiki?: string 39 39 + wiki?: string; 40 40 /** The album art of the song. */ 41 41 - albumArt?: BlobRef 41 41 + albumArt?: BlobRef; 42 42 + /** The URL of the album art of the song. */ 43 43 + albumArtUrl?: string; 42 44 /** The YouTube link of the song. */ 43 43 - youtubeLink?: string 45 45 + youtubeLink?: string; 44 46 /** The Spotify link of the song. */ 45 45 - spotifyLink?: string 47 47 + spotifyLink?: string; 46 48 /** The Tidal link of the song. */ 47 47 - tidalLink?: string 49 49 + tidalLink?: string; 48 50 /** The Apple Music link of the song. */ 49 49 - appleMusicLink?: string 51 51 + appleMusicLink?: string; 50 52 /** The date when the song was created. */ 51 51 - createdAt: string 53 53 + createdAt: string; 52 54 /** The MusicBrainz ID of the song. */ 53 53 - mbid?: string 55 55 + mbid?: string; 54 56 /** The label of the song. */ 55 55 - label?: string 56 56 - [k: string]: unknown 57 57 + label?: string; 58 58 + [k: string]: unknown; 57 59 } 58 60 59 61 export function isRecord(v: unknown): v is Record { 60 62 return ( 61 63 isObj(v) && 62 62 - hasProp(v, '$type') && 63 63 - (v.$type === 'app.rocksky.scrobble#main' || 64 64 - v.$type === 'app.rocksky.scrobble') 65 65 - ) 64 64 + hasProp(v, "$type") && 65 65 + (v.$type === "app.rocksky.scrobble#main" || 66 66 + v.$type === "app.rocksky.scrobble") 67 67 + ); 66 68 } 67 69 68 70 export function validateRecord(v: unknown): ValidationResult { 69 69 - return lexicons.validate('app.rocksky.scrobble#main', v) 71 71 + return lexicons.validate("app.rocksky.scrobble#main", v); 70 72 }

+48 -48

apps/api/src/lexicon/types/app/rocksky/scrobble/createScrobble.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyScrobbleDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyScrobbleDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The title of the track being scrobbled */ 16 16 - title: string 16 16 + title: string; 17 17 /** The artist of the track being scrobbled */ 18 18 - artist: string 18 18 + artist: string; 19 19 /** The album of the track being scrobbled */ 20 20 - album?: string 20 20 + album?: string; 21 21 /** The duration of the track in seconds */ 22 22 - duration?: number 22 22 + duration?: number; 23 23 /** The MusicBrainz ID of the track, if available */ 24 24 - mbId?: string 24 24 + mbId?: string; 25 25 /** The URL of the album art for the track */ 26 26 - albumArt?: string 26 26 + albumArt?: string; 27 27 /** The track number of the track in the album */ 28 28 - trackNumber?: number 28 28 + trackNumber?: number; 29 29 /** The release date of the track, formatted as YYYY-MM-DD */ 30 30 - releaseDate?: string 30 30 + releaseDate?: string; 31 31 /** The year the track was released */ 32 32 - year?: number 32 32 + year?: number; 33 33 /** The disc number of the track in the album, if applicable */ 34 34 - discNumber?: number 34 34 + discNumber?: number; 35 35 /** The lyrics of the track, if available */ 36 36 - lyrics?: string 36 36 + lyrics?: string; 37 37 /** The composer of the track, if available */ 38 38 - composer?: string 38 38 + composer?: string; 39 39 /** The copyright message for the track, if available */ 40 40 - copyrightMessage?: string 40 40 + copyrightMessage?: string; 41 41 /** The record label of the track, if available */ 42 42 - label?: string 42 42 + label?: string; 43 43 /** The URL of the artist's picture, if available */ 44 44 - artistPicture?: string 44 44 + artistPicture?: string; 45 45 /** The Spotify link for the track, if available */ 46 46 - spotifyLink?: string 46 46 + spotifyLink?: string; 47 47 /** The Last.fm link for the track, if available */ 48 48 - lastfmLink?: string 48 48 + lastfmLink?: string; 49 49 /** The Tidal link for the track, if available */ 50 50 - tidalLink?: string 50 50 + tidalLink?: string; 51 51 /** The Apple Music link for the track, if available */ 52 52 - appleMusicLink?: string 52 52 + appleMusicLink?: string; 53 53 /** The Youtube link for the track, if available */ 54 54 - youtubeLink?: string 54 54 + youtubeLink?: string; 55 55 /** The Deezer link for the track, if available */ 56 56 - deezerLink?: string 56 56 + deezerLink?: string; 57 57 /** The timestamp of the scrobble in milliseconds since epoch */ 58 58 - timestamp?: number 59 59 - [k: string]: unknown 58 58 + timestamp?: number; 59 59 + [k: string]: unknown; 60 60 } 61 61 62 62 - export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewBasic 62 62 + export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewBasic; 63 63 64 64 export interface HandlerInput { 65 65 - encoding: 'application/json' 66 66 - body: InputSchema 65 65 + encoding: "application/json"; 66 66 + body: InputSchema; 67 67 } 68 68 69 69 export interface HandlerSuccess { 70 70 - encoding: 'application/json' 71 71 - body: OutputSchema 72 72 - headers?: { [key: string]: string } 70 70 + encoding: "application/json"; 71 71 + body: OutputSchema; 72 72 + headers?: { [key: string]: string }; 73 73 } 74 74 75 75 export interface HandlerError { 76 76 - status: number 77 77 - message?: string 76 76 + status: number; 77 77 + message?: string; 78 78 } 79 79 80 80 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 80 80 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 81 81 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 82 82 - auth: HA 83 83 - params: QueryParams 84 84 - input: HandlerInput 85 85 - req: express.Request 86 86 - res: express.Response 87 87 - resetRouteRateLimits: () => Promise<void> 88 88 - } 82 82 + auth: HA; 83 83 + params: QueryParams; 84 84 + input: HandlerInput; 85 85 + req: express.Request; 86 86 + res: express.Response; 87 87 + resetRouteRateLimits: () => Promise<void>; 88 88 + }; 89 89 export type Handler<HA extends HandlerAuth = never> = ( 90 90 ctx: HandlerReqCtx<HA>, 91 91 - ) => Promise<HandlerOutput> | HandlerOutput 91 91 + ) => Promise<HandlerOutput> | HandlerOutput;

+40 -40

apps/api/src/lexicon/types/app/rocksky/scrobble/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface ScrobbleViewBasic { 10 10 /** The unique identifier of the scrobble. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The handle of the user who created the scrobble. */ 13 13 - user?: string 13 13 + user?: string; 14 14 /** The display name of the user who created the scrobble. */ 15 15 - userDisplayName?: string 15 15 + userDisplayName?: string; 16 16 /** The avatar URL of the user who created the scrobble. */ 17 17 - userAvatar?: string 17 17 + userAvatar?: string; 18 18 /** The title of the scrobble. */ 19 19 - title?: string 19 19 + title?: string; 20 20 /** The artist of the song. */ 21 21 - artist?: string 21 21 + artist?: string; 22 22 /** The URI of the artist. */ 23 23 - artistUri?: string 23 23 + artistUri?: string; 24 24 /** The album of the song. */ 25 25 - album?: string 25 25 + album?: string; 26 26 /** The URI of the album. */ 27 27 - albumUri?: string 27 27 + albumUri?: string; 28 28 /** The album art URL of the song. */ 29 29 - cover?: string 29 29 + cover?: string; 30 30 /** The timestamp when the scrobble was created. */ 31 31 - date?: string 31 31 + date?: string; 32 32 /** The URI of the scrobble. */ 33 33 - uri?: string 33 33 + uri?: string; 34 34 /** The SHA256 hash of the scrobble data. */ 35 35 - sha256?: string 36 36 - [k: string]: unknown 35 35 + sha256?: string; 36 36 + [k: string]: unknown; 37 37 } 38 38 39 39 export function isScrobbleViewBasic(v: unknown): v is ScrobbleViewBasic { 40 40 return ( 41 41 isObj(v) && 42 42 - hasProp(v, '$type') && 43 43 - v.$type === 'app.rocksky.scrobble.defs#scrobbleViewBasic' 44 44 - ) 42 42 + hasProp(v, "$type") && 43 43 + v.$type === "app.rocksky.scrobble.defs#scrobbleViewBasic" 44 44 + ); 45 45 } 46 46 47 47 export function validateScrobbleViewBasic(v: unknown): ValidationResult { 48 48 - return lexicons.validate('app.rocksky.scrobble.defs#scrobbleViewBasic', v) 48 48 + return lexicons.validate("app.rocksky.scrobble.defs#scrobbleViewBasic", v); 49 49 } 50 50 51 51 export interface ScrobbleViewDetailed { 52 52 /** The unique identifier of the scrobble. */ 53 53 - id?: string 53 53 + id?: string; 54 54 /** The handle of the user who created the scrobble. */ 55 55 - user?: string 55 55 + user?: string; 56 56 /** The title of the scrobble. */ 57 57 - title?: string 57 57 + title?: string; 58 58 /** The artist of the song. */ 59 59 - artist?: string 59 59 + artist?: string; 60 60 /** The URI of the artist. */ 61 61 - artistUri?: string 61 61 + artistUri?: string; 62 62 /** The album of the song. */ 63 63 - album?: string 63 63 + album?: string; 64 64 /** The URI of the album. */ 65 65 - albumUri?: string 65 65 + albumUri?: string; 66 66 /** The album art URL of the song. */ 67 67 - cover?: string 67 67 + cover?: string; 68 68 /** The timestamp when the scrobble was created. */ 69 69 - date?: string 69 69 + date?: string; 70 70 /** The URI of the scrobble. */ 71 71 - uri?: string 71 71 + uri?: string; 72 72 /** The SHA256 hash of the scrobble data. */ 73 73 - sha256?: string 73 73 + sha256?: string; 74 74 /** The number of listeners */ 75 75 - listeners?: number 75 75 + listeners?: number; 76 76 /** The number of scrobbles for this song */ 77 77 - scrobbles?: number 78 78 - [k: string]: unknown 77 77 + scrobbles?: number; 78 78 + [k: string]: unknown; 79 79 } 80 80 81 81 export function isScrobbleViewDetailed(v: unknown): v is ScrobbleViewDetailed { 82 82 return ( 83 83 isObj(v) && 84 84 - hasProp(v, '$type') && 85 85 - v.$type === 'app.rocksky.scrobble.defs#scrobbleViewDetailed' 86 86 - ) 84 84 + hasProp(v, "$type") && 85 85 + v.$type === "app.rocksky.scrobble.defs#scrobbleViewDetailed" 86 86 + ); 87 87 } 88 88 89 89 export function validateScrobbleViewDetailed(v: unknown): ValidationResult { 90 90 - return lexicons.validate('app.rocksky.scrobble.defs#scrobbleViewDetailed', v) 90 90 + return lexicons.validate("app.rocksky.scrobble.defs#scrobbleViewDetailed", v); 91 91 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/scrobble/getScrobble.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyScrobbleDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyScrobbleDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the scrobble */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/scrobble/getScrobbles.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyScrobbleDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyScrobbleDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did?: string 14 14 + did?: string; 15 15 /** The maximum number of scrobbles to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The offset for pagination */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[] 25 25 - [k: string]: unknown 24 24 + scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+14 -14

apps/api/src/lexicon/types/app/rocksky/shout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 8 8 - import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 + import * as ComAtprotoRepoStrongRef from "../../com/atproto/repo/strongRef"; 9 9 10 10 export interface Record { 11 11 /** The message of the shout. */ 12 12 - message: string 12 12 + message: string; 13 13 /** The date when the shout was created. */ 14 14 - createdAt: string 15 15 - parent?: ComAtprotoRepoStrongRef.Main 16 16 - subject: ComAtprotoRepoStrongRef.Main 17 17 - [k: string]: unknown 14 14 + createdAt: string; 15 15 + parent?: ComAtprotoRepoStrongRef.Main; 16 16 + subject: ComAtprotoRepoStrongRef.Main; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 export function isRecord(v: unknown): v is Record { 21 21 return ( 22 22 isObj(v) && 23 23 - hasProp(v, '$type') && 24 24 - (v.$type === 'app.rocksky.shout#main' || v.$type === 'app.rocksky.shout') 25 25 - ) 23 23 + hasProp(v, "$type") && 24 24 + (v.$type === "app.rocksky.shout#main" || v.$type === "app.rocksky.shout") 25 25 + ); 26 26 } 27 27 28 28 export function validateRecord(v: unknown): ValidationResult { 29 29 - return lexicons.validate('app.rocksky.shout#main', v) 29 29 + return lexicons.validate("app.rocksky.shout#main", v); 30 30 }

+27 -27

apps/api/src/lexicon/types/app/rocksky/shout/createShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The content of the shout */ 16 16 - message?: string 17 17 - [k: string]: unknown 16 16 + message?: string; 17 17 + [k: string]: unknown; 18 18 } 19 19 20 20 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 20 20 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 21 21 22 22 export interface HandlerInput { 23 23 - encoding: 'application/json' 24 24 - body: InputSchema 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 } 26 26 27 27 export interface HandlerSuccess { 28 28 - encoding: 'application/json' 29 29 - body: OutputSchema 30 30 - headers?: { [key: string]: string } 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 } 32 32 33 33 export interface HandlerError { 34 34 - status: number 35 35 - message?: string 34 34 + status: number; 35 35 + message?: string; 36 36 } 37 37 38 38 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 39 39 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 40 40 - auth: HA 41 41 - params: QueryParams 42 42 - input: HandlerInput 43 43 - req: express.Request 44 44 - res: express.Response 45 45 - resetRouteRateLimits: () => Promise<void> 46 46 - } 40 40 + auth: HA; 41 41 + params: QueryParams; 42 42 + input: HandlerInput; 43 43 + req: express.Request; 44 44 + res: express.Response; 45 45 + resetRouteRateLimits: () => Promise<void>; 46 46 + }; 47 47 export type Handler<HA extends HandlerAuth = never> = ( 48 48 ctx: HandlerReqCtx<HA>, 49 49 - ) => Promise<HandlerOutput> | HandlerOutput 49 49 + ) => Promise<HandlerOutput> | HandlerOutput;

+24 -24

apps/api/src/lexicon/types/app/rocksky/shout/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Author { 10 10 /** The unique identifier of the author. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The decentralized identifier (DID) of the author. */ 13 13 - did?: string 13 13 + did?: string; 14 14 /** The handle of the author. */ 15 15 - handle?: string 15 15 + handle?: string; 16 16 /** The display name of the author. */ 17 17 - displayName?: string 17 17 + displayName?: string; 18 18 /** The URL of the author's avatar image. */ 19 19 - avatar?: string 20 20 - [k: string]: unknown 19 19 + avatar?: string; 20 20 + [k: string]: unknown; 21 21 } 22 22 23 23 export function isAuthor(v: unknown): v is Author { 24 24 return ( 25 25 isObj(v) && 26 26 - hasProp(v, '$type') && 27 27 - v.$type === 'app.rocksky.shout.defs#author' 28 28 - ) 26 26 + hasProp(v, "$type") && 27 27 + v.$type === "app.rocksky.shout.defs#author" 28 28 + ); 29 29 } 30 30 31 31 export function validateAuthor(v: unknown): ValidationResult { 32 32 - return lexicons.validate('app.rocksky.shout.defs#author', v) 32 32 + return lexicons.validate("app.rocksky.shout.defs#author", v); 33 33 } 34 34 35 35 export interface ShoutView { 36 36 /** The unique identifier of the shout. */ 37 37 - id?: string 37 37 + id?: string; 38 38 /** The content of the shout. */ 39 39 - message?: string 39 39 + message?: string; 40 40 /** The ID of the parent shout if this is a reply, otherwise null. */ 41 41 - parent?: string 41 41 + parent?: string; 42 42 /** The date and time when the shout was created. */ 43 43 - createdAt?: string 44 44 - author?: Author 45 45 - [k: string]: unknown 43 43 + createdAt?: string; 44 44 + author?: Author; 45 45 + [k: string]: unknown; 46 46 } 47 47 48 48 export function isShoutView(v: unknown): v is ShoutView { 49 49 return ( 50 50 isObj(v) && 51 51 - hasProp(v, '$type') && 52 52 - v.$type === 'app.rocksky.shout.defs#shoutView' 53 53 - ) 51 51 + hasProp(v, "$type") && 52 52 + v.$type === "app.rocksky.shout.defs#shoutView" 53 53 + ); 54 54 } 55 55 56 56 export function validateShoutView(v: unknown): ValidationResult { 57 57 - return lexicons.validate('app.rocksky.shout.defs#shoutView', v) 57 57 + return lexicons.validate("app.rocksky.shout.defs#shoutView", v); 58 58 }

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/getAlbumShouts.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the album to retrieve shouts for */ 14 14 - uri: string 14 14 + uri: string; 15 15 /** The maximum number of shouts to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The number of shouts to skip before starting to collect the result set */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - shouts?: AppRockskyShoutDefs.ShoutViewBasic[] 25 25 - [k: string]: unknown 24 24 + shouts?: AppRockskyShoutDefs.ShoutViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/getArtistShouts.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the artist to retrieve shouts for */ 14 14 - uri: string 14 14 + uri: string; 15 15 /** The maximum number of shouts to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The number of shouts to skip before starting to collect the result set */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - shouts?: AppRockskyShoutDefs.ShoutViewBasic[] 25 25 - [k: string]: unknown 24 24 + shouts?: AppRockskyShoutDefs.ShoutViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/getProfileShouts.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the actor */ 14 14 - did: string 14 14 + did: string; 15 15 /** The offset for pagination */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 /** The maximum number of shouts to return */ 18 18 - limit?: number 18 18 + limit?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - shouts?: AppRockskyShoutDefs.ShoutViewBasic[] 25 25 - [k: string]: unknown 24 24 + shouts?: AppRockskyShoutDefs.ShoutViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/getShoutReplies.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the shout to retrieve replies for */ 14 14 - uri: string 14 14 + uri: string; 15 15 /** The maximum number of shouts to return */ 16 16 - limit?: number 16 16 + limit?: number; 17 17 /** The number of shouts to skip before starting to collect the result set */ 18 18 - offset?: number 18 18 + offset?: number; 19 19 } 20 20 21 21 - export type InputSchema = undefined 21 21 + export type InputSchema = undefined; 22 22 23 23 export interface OutputSchema { 24 24 - shouts?: AppRockskyShoutDefs.ShoutViewBasic[] 25 25 - [k: string]: unknown 24 24 + shouts?: AppRockskyShoutDefs.ShoutViewBasic[]; 25 25 + [k: string]: unknown; 26 26 } 27 27 28 28 - export type HandlerInput = undefined 28 28 + export type HandlerInput = undefined; 29 29 30 30 export interface HandlerSuccess { 31 31 - encoding: 'application/json' 32 32 - body: OutputSchema 33 33 - headers?: { [key: string]: string } 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 } 35 35 36 36 export interface HandlerError { 37 37 - status: number 38 38 - message?: string 37 37 + status: number; 38 38 + message?: string; 39 39 } 40 40 41 41 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 42 42 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 43 43 - auth: HA 44 44 - params: QueryParams 45 45 - input: HandlerInput 46 46 - req: express.Request 47 47 - res: express.Response 48 48 - resetRouteRateLimits: () => Promise<void> 49 49 - } 43 43 + auth: HA; 44 44 + params: QueryParams; 45 45 + input: HandlerInput; 46 46 + req: express.Request; 47 47 + res: express.Response; 48 48 + resetRouteRateLimits: () => Promise<void>; 49 49 + }; 50 50 export type Handler<HA extends HandlerAuth = never> = ( 51 51 ctx: HandlerReqCtx<HA>, 52 52 - ) => Promise<HandlerOutput> | HandlerOutput 52 52 + ) => Promise<HandlerOutput> | HandlerOutput;

+26 -26

apps/api/src/lexicon/types/app/rocksky/shout/getTrackShouts.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The URI of the track to retrieve shouts for */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 17 17 + export type InputSchema = undefined; 18 18 19 19 export interface OutputSchema { 20 20 - shouts?: AppRockskyShoutDefs.ShoutViewBasic[] 21 21 - [k: string]: unknown 20 20 + shouts?: AppRockskyShoutDefs.ShoutViewBasic[]; 21 21 + [k: string]: unknown; 22 22 } 23 23 24 24 - export type HandlerInput = undefined 24 24 + export type HandlerInput = undefined; 25 25 26 26 export interface HandlerSuccess { 27 27 - encoding: 'application/json' 28 28 - body: OutputSchema 29 29 - headers?: { [key: string]: string } 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 } 31 31 32 32 export interface HandlerError { 33 33 - status: number 34 34 - message?: string 33 33 + status: number; 34 34 + message?: string; 35 35 } 36 36 37 37 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 38 38 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 39 39 - auth: HA 40 40 - params: QueryParams 41 41 - input: HandlerInput 42 42 - req: express.Request 43 43 - res: express.Response 44 44 - resetRouteRateLimits: () => Promise<void> 45 45 - } 39 39 + auth: HA; 40 40 + params: QueryParams; 41 41 + input: HandlerInput; 42 42 + req: express.Request; 43 43 + res: express.Response; 44 44 + resetRouteRateLimits: () => Promise<void>; 45 45 + }; 46 46 export type Handler<HA extends HandlerAuth = never> = ( 47 47 ctx: HandlerReqCtx<HA>, 48 48 - ) => Promise<HandlerOutput> | HandlerOutput 48 48 + ) => Promise<HandlerOutput> | HandlerOutput;

+25 -25

apps/api/src/lexicon/types/app/rocksky/shout/removeShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The ID of the shout to be removed */ 14 14 - id: string 14 14 + id: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/replyShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the shout to reply to */ 16 16 - shoutId: string 16 16 + shoutId: string; 17 17 /** The content of the reply */ 18 18 - message: string 19 19 - [k: string]: unknown 18 18 + message: string; 19 19 + [k: string]: unknown; 20 20 } 21 21 22 22 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 22 22 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 23 23 24 24 export interface HandlerInput { 25 25 - encoding: 'application/json' 26 26 - body: InputSchema 25 25 + encoding: "application/json"; 26 26 + body: InputSchema; 27 27 } 28 28 29 29 export interface HandlerSuccess { 30 30 - encoding: 'application/json' 31 31 - body: OutputSchema 32 32 - headers?: { [key: string]: string } 30 30 + encoding: "application/json"; 31 31 + body: OutputSchema; 32 32 + headers?: { [key: string]: string }; 33 33 } 34 34 35 35 export interface HandlerError { 36 36 - status: number 37 37 - message?: string 36 36 + status: number; 37 37 + message?: string; 38 38 } 39 39 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA 43 43 - params: QueryParams 44 44 - input: HandlerInput 45 45 - req: express.Request 46 46 - res: express.Response 47 47 - resetRouteRateLimits: () => Promise<void> 48 48 - } 42 42 + auth: HA; 43 43 + params: QueryParams; 44 44 + input: HandlerInput; 45 45 + req: express.Request; 46 46 + res: express.Response; 47 47 + resetRouteRateLimits: () => Promise<void>; 48 48 + }; 49 49 export type Handler<HA extends HandlerAuth = never> = ( 50 50 ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput 51 51 + ) => Promise<HandlerOutput> | HandlerOutput;

+28 -28

apps/api/src/lexicon/types/app/rocksky/shout/reportShout.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyShoutDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyShoutDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The unique identifier of the shout to report */ 16 16 - shoutId: string 16 16 + shoutId: string; 17 17 /** The reason for reporting the shout */ 18 18 - reason?: string 19 19 - [k: string]: unknown 18 18 + reason?: string; 19 19 + [k: string]: unknown; 20 20 } 21 21 22 22 - export type OutputSchema = AppRockskyShoutDefs.ShoutView 22 22 + export type OutputSchema = AppRockskyShoutDefs.ShoutView; 23 23 24 24 export interface HandlerInput { 25 25 - encoding: 'application/json' 26 26 - body: InputSchema 25 25 + encoding: "application/json"; 26 26 + body: InputSchema; 27 27 } 28 28 29 29 export interface HandlerSuccess { 30 30 - encoding: 'application/json' 31 31 - body: OutputSchema 32 32 - headers?: { [key: string]: string } 30 30 + encoding: "application/json"; 31 31 + body: OutputSchema; 32 32 + headers?: { [key: string]: string }; 33 33 } 34 34 35 35 export interface HandlerError { 36 36 - status: number 37 37 - message?: string 36 36 + status: number; 37 37 + message?: string; 38 38 } 39 39 40 40 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 40 40 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 41 41 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 42 42 - auth: HA 43 43 - params: QueryParams 44 44 - input: HandlerInput 45 45 - req: express.Request 46 46 - res: express.Response 47 47 - resetRouteRateLimits: () => Promise<void> 48 48 - } 42 42 + auth: HA; 43 43 + params: QueryParams; 44 44 + input: HandlerInput; 45 45 + req: express.Request; 46 46 + res: express.Response; 47 47 + resetRouteRateLimits: () => Promise<void>; 48 48 + }; 49 49 export type Handler<HA extends HandlerAuth = never> = ( 50 50 ctx: HandlerReqCtx<HA>, 51 51 - ) => Promise<HandlerOutput> | HandlerOutput 51 51 + ) => Promise<HandlerOutput> | HandlerOutput;

+34 -32

apps/api/src/lexicon/types/app/rocksky/song.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Record { 10 10 /** The title of the song. */ 11 11 - title: string 11 11 + title: string; 12 12 /** The artist of the song. */ 13 13 - artist: string 13 13 + artist: string; 14 14 /** The album artist of the song. */ 15 15 - albumArtist: string 15 15 + albumArtist: string; 16 16 /** The album of the song. */ 17 17 - album: string 17 17 + album: string; 18 18 /** The duration of the song in seconds. */ 19 19 - duration: number 19 19 + duration: number; 20 20 /** The track number of the song in the album. */ 21 21 - trackNumber?: number 21 21 + trackNumber?: number; 22 22 /** The disc number of the song in the album. */ 23 23 - discNumber?: number 23 23 + discNumber?: number; 24 24 /** The release date of the song. */ 25 25 - releaseDate?: string 25 25 + releaseDate?: string; 26 26 /** The year the song was released. */ 27 27 - year?: number 27 27 + year?: number; 28 28 /** The genre of the song. */ 29 29 - genre?: string 29 29 + genre?: string; 30 30 /** The tags of the song. */ 31 31 - tags?: string[] 31 31 + tags?: string[]; 32 32 /** The composer of the song. */ 33 33 - composer?: string 33 33 + composer?: string; 34 34 /** The lyrics of the song. */ 35 35 - lyrics?: string 35 35 + lyrics?: string; 36 36 /** The copyright message of the song. */ 37 37 - copyrightMessage?: string 37 37 + copyrightMessage?: string; 38 38 /** Informations about the song */ 39 39 - wiki?: string 39 39 + wiki?: string; 40 40 /** The album art of the song. */ 41 41 - albumArt?: BlobRef 41 41 + albumArt?: BlobRef; 42 42 + /** The URL of the album art of the song. */ 43 43 + albumArtUrl?: string; 42 44 /** The YouTube link of the song. */ 43 43 - youtubeLink?: string 45 45 + youtubeLink?: string; 44 46 /** The Spotify link of the song. */ 45 45 - spotifyLink?: string 47 47 + spotifyLink?: string; 46 48 /** The Tidal link of the song. */ 47 47 - tidalLink?: string 49 49 + tidalLink?: string; 48 50 /** The Apple Music link of the song. */ 49 49 - appleMusicLink?: string 51 51 + appleMusicLink?: string; 50 52 /** The date when the song was created. */ 51 51 - createdAt: string 53 53 + createdAt: string; 52 54 /** The MusicBrainz ID of the song. */ 53 53 - mbid?: string 55 55 + mbid?: string; 54 56 /** The label of the song. */ 55 55 - label?: string 56 56 - [k: string]: unknown 57 57 + label?: string; 58 58 + [k: string]: unknown; 57 59 } 58 60 59 61 export function isRecord(v: unknown): v is Record { 60 62 return ( 61 63 isObj(v) && 62 62 - hasProp(v, '$type') && 63 63 - (v.$type === 'app.rocksky.song#main' || v.$type === 'app.rocksky.song') 64 64 - ) 64 64 + hasProp(v, "$type") && 65 65 + (v.$type === "app.rocksky.song#main" || v.$type === "app.rocksky.song") 66 66 + ); 65 67 } 66 68 67 69 export function validateRecord(v: unknown): ValidationResult { 68 68 - return lexicons.validate('app.rocksky.song#main', v) 70 70 + return lexicons.validate("app.rocksky.song#main", v); 69 71 }

+38 -38

apps/api/src/lexicon/types/app/rocksky/song/createSong.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "./defs"; 11 11 12 12 - export type QueryParams = {} 12 12 + export interface QueryParams {} 13 13 14 14 export interface InputSchema { 15 15 /** The title of the song */ 16 16 - title: string 16 16 + title: string; 17 17 /** The artist of the song */ 18 18 - artist: string 18 18 + artist: string; 19 19 /** The album artist of the song, if different from the main artist */ 20 20 - albumArtist: string 20 20 + albumArtist: string; 21 21 /** The album of the song, if applicable */ 22 22 - album: string 22 22 + album: string; 23 23 /** The duration of the song in seconds */ 24 24 - duration?: number 24 24 + duration?: number; 25 25 /** The MusicBrainz ID of the song, if available */ 26 26 - mbId?: string 26 26 + mbId?: string; 27 27 /** The URL of the album art for the song */ 28 28 - albumArt?: string 28 28 + albumArt?: string; 29 29 /** The track number of the song in the album, if applicable */ 30 30 - trackNumber?: number 30 30 + trackNumber?: number; 31 31 /** The release date of the song, formatted as YYYY-MM-DD */ 32 32 - releaseDate?: string 32 32 + releaseDate?: string; 33 33 /** The year the song was released */ 34 34 - year?: number 34 34 + year?: number; 35 35 /** The disc number of the song in the album, if applicable */ 36 36 - discNumber?: number 36 36 + discNumber?: number; 37 37 /** The lyrics of the song, if available */ 38 38 - lyrics?: string 39 39 - [k: string]: unknown 38 38 + lyrics?: string; 39 39 + [k: string]: unknown; 40 40 } 41 41 42 42 - export type OutputSchema = AppRockskySongDefs.SongViewDetailed 42 42 + export type OutputSchema = AppRockskySongDefs.SongViewDetailed; 43 43 44 44 export interface HandlerInput { 45 45 - encoding: 'application/json' 46 46 - body: InputSchema 45 45 + encoding: "application/json"; 46 46 + body: InputSchema; 47 47 } 48 48 49 49 export interface HandlerSuccess { 50 50 - encoding: 'application/json' 51 51 - body: OutputSchema 52 52 - headers?: { [key: string]: string } 50 50 + encoding: "application/json"; 51 51 + body: OutputSchema; 52 52 + headers?: { [key: string]: string }; 53 53 } 54 54 55 55 export interface HandlerError { 56 56 - status: number 57 57 - message?: string 56 56 + status: number; 57 57 + message?: string; 58 58 } 59 59 60 60 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 60 60 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 61 61 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 62 62 - auth: HA 63 63 - params: QueryParams 64 64 - input: HandlerInput 65 65 - req: express.Request 66 66 - res: express.Response 67 67 - resetRouteRateLimits: () => Promise<void> 68 68 - } 62 62 + auth: HA; 63 63 + params: QueryParams; 64 64 + input: HandlerInput; 65 65 + req: express.Request; 66 66 + res: express.Response; 67 67 + resetRouteRateLimits: () => Promise<void>; 68 68 + }; 69 69 export type Handler<HA extends HandlerAuth = never> = ( 70 70 ctx: HandlerReqCtx<HA>, 71 71 - ) => Promise<HandlerOutput> | HandlerOutput 71 71 + ) => Promise<HandlerOutput> | HandlerOutput;

+46 -46

apps/api/src/lexicon/types/app/rocksky/song/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface SongViewBasic { 10 10 /** The unique identifier of the song. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The title of the song. */ 13 13 - title?: string 13 13 + title?: string; 14 14 /** The artist of the song. */ 15 15 - artist?: string 15 15 + artist?: string; 16 16 /** The artist of the album the song belongs to. */ 17 17 - albumArtist?: string 17 17 + albumArtist?: string; 18 18 /** The URL of the album art image. */ 19 19 - albumArt?: string 19 19 + albumArt?: string; 20 20 /** The URI of the song. */ 21 21 - uri?: string 21 21 + uri?: string; 22 22 /** The album of the song. */ 23 23 - album?: string 23 23 + album?: string; 24 24 /** The duration of the song in milliseconds. */ 25 25 - duration?: number 25 25 + duration?: number; 26 26 /** The track number of the song in the album. */ 27 27 - trackNumber?: number 27 27 + trackNumber?: number; 28 28 /** The disc number of the song in the album. */ 29 29 - discNumber?: number 29 29 + discNumber?: number; 30 30 /** The number of times the song has been played. */ 31 31 - playCount?: number 31 31 + playCount?: number; 32 32 /** The number of unique listeners who have played the song. */ 33 33 - uniqueListeners?: number 33 33 + uniqueListeners?: number; 34 34 /** The URI of the album the song belongs to. */ 35 35 - albumUri?: string 35 35 + albumUri?: string; 36 36 /** The URI of the artist of the song. */ 37 37 - artistUri?: string 37 37 + artistUri?: string; 38 38 /** The SHA256 hash of the song. */ 39 39 - sha256?: string 39 39 + sha256?: string; 40 40 /** The timestamp when the song was created. */ 41 41 - createdAt?: string 42 42 - [k: string]: unknown 41 41 + createdAt?: string; 42 42 + [k: string]: unknown; 43 43 } 44 44 45 45 export function isSongViewBasic(v: unknown): v is SongViewBasic { 46 46 return ( 47 47 isObj(v) && 48 48 - hasProp(v, '$type') && 49 49 - v.$type === 'app.rocksky.song.defs#songViewBasic' 50 50 - ) 48 48 + hasProp(v, "$type") && 49 49 + v.$type === "app.rocksky.song.defs#songViewBasic" 50 50 + ); 51 51 } 52 52 53 53 export function validateSongViewBasic(v: unknown): ValidationResult { 54 54 - return lexicons.validate('app.rocksky.song.defs#songViewBasic', v) 54 54 + return lexicons.validate("app.rocksky.song.defs#songViewBasic", v); 55 55 } 56 56 57 57 export interface SongViewDetailed { 58 58 /** The unique identifier of the song. */ 59 59 - id?: string 59 59 + id?: string; 60 60 /** The title of the song. */ 61 61 - title?: string 61 61 + title?: string; 62 62 /** The artist of the song. */ 63 63 - artist?: string 63 63 + artist?: string; 64 64 /** The artist of the album the song belongs to. */ 65 65 - albumArtist?: string 65 65 + albumArtist?: string; 66 66 /** The URL of the album art image. */ 67 67 - albumArt?: string 67 67 + albumArt?: string; 68 68 /** The URI of the song. */ 69 69 - uri?: string 69 69 + uri?: string; 70 70 /** The album of the song. */ 71 71 - album?: string 71 71 + album?: string; 72 72 /** The duration of the song in milliseconds. */ 73 73 - duration?: number 73 73 + duration?: number; 74 74 /** The track number of the song in the album. */ 75 75 - trackNumber?: number 75 75 + trackNumber?: number; 76 76 /** The disc number of the song in the album. */ 77 77 - discNumber?: number 77 77 + discNumber?: number; 78 78 /** The number of times the song has been played. */ 79 79 - playCount?: number 79 79 + playCount?: number; 80 80 /** The number of unique listeners who have played the song. */ 81 81 - uniqueListeners?: number 81 81 + uniqueListeners?: number; 82 82 /** The URI of the album the song belongs to. */ 83 83 - albumUri?: string 83 83 + albumUri?: string; 84 84 /** The URI of the artist of the song. */ 85 85 - artistUri?: string 85 85 + artistUri?: string; 86 86 /** The SHA256 hash of the song. */ 87 87 - sha256?: string 87 87 + sha256?: string; 88 88 /** The timestamp when the song was created. */ 89 89 - createdAt?: string 90 90 - [k: string]: unknown 89 89 + createdAt?: string; 90 90 + [k: string]: unknown; 91 91 } 92 92 93 93 export function isSongViewDetailed(v: unknown): v is SongViewDetailed { 94 94 return ( 95 95 isObj(v) && 96 96 - hasProp(v, '$type') && 97 97 - v.$type === 'app.rocksky.song.defs#songViewDetailed' 98 98 - ) 96 96 + hasProp(v, "$type") && 97 97 + v.$type === "app.rocksky.song.defs#songViewDetailed" 98 98 + ); 99 99 } 100 100 101 101 export function validateSongViewDetailed(v: unknown): ValidationResult { 102 102 - return lexicons.validate('app.rocksky.song.defs#songViewDetailed', v) 102 102 + return lexicons.validate("app.rocksky.song.defs#songViewDetailed", v); 103 103 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/song/getSong.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The unique identifier of the song to retrieve */ 14 14 - uri: string 14 14 + uri: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskySongDefs.SongViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskySongDefs.SongViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+27 -27

apps/api/src/lexicon/types/app/rocksky/song/getSongs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskySongDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskySongDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The maximum number of songs to return */ 14 14 - limit?: number 14 14 + limit?: number; 15 15 /** The offset for pagination */ 16 16 - offset?: number 16 16 + offset?: number; 17 17 } 18 18 19 19 - export type InputSchema = undefined 19 19 + export type InputSchema = undefined; 20 20 21 21 export interface OutputSchema { 22 22 - songs?: AppRockskySongDefs.SongViewBasic[] 23 23 - [k: string]: unknown 22 22 + songs?: AppRockskySongDefs.SongViewBasic[]; 23 23 + [k: string]: unknown; 24 24 } 25 25 26 26 - export type HandlerInput = undefined 26 26 + export type HandlerInput = undefined; 27 27 28 28 export interface HandlerSuccess { 29 29 - encoding: 'application/json' 30 30 - body: OutputSchema 31 31 - headers?: { [key: string]: string } 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 } 33 33 34 34 export interface HandlerError { 35 35 - status: number 36 36 - message?: string 35 35 + status: number; 36 36 + message?: string; 37 37 } 38 38 39 39 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 40 40 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 41 41 - auth: HA 42 42 - params: QueryParams 43 43 - input: HandlerInput 44 44 - req: express.Request 45 45 - res: express.Response 46 46 - resetRouteRateLimits: () => Promise<void> 47 47 - } 41 41 + auth: HA; 42 42 + params: QueryParams; 43 43 + input: HandlerInput; 44 44 + req: express.Request; 45 45 + res: express.Response; 46 46 + resetRouteRateLimits: () => Promise<void>; 47 47 + }; 48 48 export type Handler<HA extends HandlerAuth = never> = ( 49 49 ctx: HandlerReqCtx<HA>, 50 50 - ) => Promise<HandlerOutput> | HandlerOutput 50 50 + ) => Promise<HandlerOutput> | HandlerOutput;

+15 -15

apps/api/src/lexicon/types/app/rocksky/spotify/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface SpotifyTrackView { 10 10 /** The unique identifier of the Spotify track. */ 11 11 - id?: string 11 11 + id?: string; 12 12 /** The name of the track. */ 13 13 - name?: string 13 13 + name?: string; 14 14 /** The name of the artist. */ 15 15 - artist?: string 15 15 + artist?: string; 16 16 /** The name of the album. */ 17 17 - album?: string 17 17 + album?: string; 18 18 /** The duration of the track in milliseconds. */ 19 19 - duration?: number 19 19 + duration?: number; 20 20 /** A URL to a preview of the track. */ 21 21 - previewUrl?: string 22 22 - [k: string]: unknown 21 21 + previewUrl?: string; 22 22 + [k: string]: unknown; 23 23 } 24 24 25 25 export function isSpotifyTrackView(v: unknown): v is SpotifyTrackView { 26 26 return ( 27 27 isObj(v) && 28 28 - hasProp(v, '$type') && 29 29 - v.$type === 'app.rocksky.spotify.defs#spotifyTrackView' 30 30 - ) 28 28 + hasProp(v, "$type") && 29 29 + v.$type === "app.rocksky.spotify.defs#spotifyTrackView" 30 30 + ); 31 31 } 32 32 33 33 export function validateSpotifyTrackView(v: unknown): ValidationResult { 34 34 - return lexicons.validate('app.rocksky.spotify.defs#spotifyTrackView', v) 34 34 + return lexicons.validate("app.rocksky.spotify.defs#spotifyTrackView", v); 35 35 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/spotify/getCurrentlyPlaying.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyPlayerDefs from '../player/defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyPlayerDefs from "../player/defs"; 11 11 12 12 export interface QueryParams { 13 13 /** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */ 14 14 - actor?: string 14 14 + actor?: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/spotify/next.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 - export type QueryParams = {} 11 11 + export interface QueryParams {} 12 12 13 13 - export type InputSchema = undefined 14 14 - export type HandlerInput = undefined 13 13 + export type InputSchema = undefined; 14 14 + export type HandlerInput = undefined; 15 15 16 16 export interface HandlerError { 17 17 - status: number 18 18 - message?: string 17 17 + status: number; 18 18 + message?: string; 19 19 } 20 20 21 21 - export type HandlerOutput = HandlerError | void 21 21 + export type HandlerOutput = HandlerError | void; 22 22 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 23 23 - auth: HA 24 24 - params: QueryParams 25 25 - input: HandlerInput 26 26 - req: express.Request 27 27 - res: express.Response 28 28 - resetRouteRateLimits: () => Promise<void> 29 29 - } 23 23 + auth: HA; 24 24 + params: QueryParams; 25 25 + input: HandlerInput; 26 26 + req: express.Request; 27 27 + res: express.Response; 28 28 + resetRouteRateLimits: () => Promise<void>; 29 29 + }; 30 30 export type Handler<HA extends HandlerAuth = never> = ( 31 31 ctx: HandlerReqCtx<HA>, 32 32 - ) => Promise<HandlerOutput> | HandlerOutput 32 32 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/spotify/pause.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 - export type QueryParams = {} 11 11 + export interface QueryParams {} 12 12 13 13 - export type InputSchema = undefined 14 14 - export type HandlerInput = undefined 13 13 + export type InputSchema = undefined; 14 14 + export type HandlerInput = undefined; 15 15 16 16 export interface HandlerError { 17 17 - status: number 18 18 - message?: string 17 17 + status: number; 18 18 + message?: string; 19 19 } 20 20 21 21 - export type HandlerOutput = HandlerError | void 21 21 + export type HandlerOutput = HandlerError | void; 22 22 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 23 23 - auth: HA 24 24 - params: QueryParams 25 25 - input: HandlerInput 26 26 - req: express.Request 27 27 - res: express.Response 28 28 - resetRouteRateLimits: () => Promise<void> 29 29 - } 23 23 + auth: HA; 24 24 + params: QueryParams; 25 25 + input: HandlerInput; 26 26 + req: express.Request; 27 27 + res: express.Response; 28 28 + resetRouteRateLimits: () => Promise<void>; 29 29 + }; 30 30 export type Handler<HA extends HandlerAuth = never> = ( 31 31 ctx: HandlerReqCtx<HA>, 32 32 - ) => Promise<HandlerOutput> | HandlerOutput 32 32 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/spotify/play.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 - export type QueryParams = {} 11 11 + export interface QueryParams {} 12 12 13 13 - export type InputSchema = undefined 14 14 - export type HandlerInput = undefined 13 13 + export type InputSchema = undefined; 14 14 + export type HandlerInput = undefined; 15 15 16 16 export interface HandlerError { 17 17 - status: number 18 18 - message?: string 17 17 + status: number; 18 18 + message?: string; 19 19 } 20 20 21 21 - export type HandlerOutput = HandlerError | void 21 21 + export type HandlerOutput = HandlerError | void; 22 22 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 23 23 - auth: HA 24 24 - params: QueryParams 25 25 - input: HandlerInput 26 26 - req: express.Request 27 27 - res: express.Response 28 28 - resetRouteRateLimits: () => Promise<void> 29 29 - } 23 23 + auth: HA; 24 24 + params: QueryParams; 25 25 + input: HandlerInput; 26 26 + req: express.Request; 27 27 + res: express.Response; 28 28 + resetRouteRateLimits: () => Promise<void>; 29 29 + }; 30 30 export type Handler<HA extends HandlerAuth = never> = ( 31 31 ctx: HandlerReqCtx<HA>, 32 32 - ) => Promise<HandlerOutput> | HandlerOutput 32 32 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/spotify/previous.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 - export type QueryParams = {} 11 11 + export interface QueryParams {} 12 12 13 13 - export type InputSchema = undefined 14 14 - export type HandlerInput = undefined 13 13 + export type InputSchema = undefined; 14 14 + export type HandlerInput = undefined; 15 15 16 16 export interface HandlerError { 17 17 - status: number 18 18 - message?: string 17 17 + status: number; 18 18 + message?: string; 19 19 } 20 20 21 21 - export type HandlerOutput = HandlerError | void 21 21 + export type HandlerOutput = HandlerError | void; 22 22 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 23 23 - auth: HA 24 24 - params: QueryParams 25 25 - input: HandlerInput 26 26 - req: express.Request 27 27 - res: express.Response 28 28 - resetRouteRateLimits: () => Promise<void> 29 29 - } 23 23 + auth: HA; 24 24 + params: QueryParams; 25 25 + input: HandlerInput; 26 26 + req: express.Request; 27 27 + res: express.Response; 28 28 + resetRouteRateLimits: () => Promise<void>; 29 29 + }; 30 30 export type Handler<HA extends HandlerAuth = never> = ( 31 31 ctx: HandlerReqCtx<HA>, 32 32 - ) => Promise<HandlerOutput> | HandlerOutput 32 32 + ) => Promise<HandlerOutput> | HandlerOutput;

+20 -20

apps/api/src/lexicon/types/app/rocksky/spotify/seek.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import { type HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 11 11 export interface QueryParams { 12 12 /** The position in seconds to seek to */ 13 13 - position: number 13 13 + position: number; 14 14 } 15 15 16 16 - export type InputSchema = undefined 17 17 - export type HandlerInput = undefined 16 16 + export type InputSchema = undefined; 17 17 + export type HandlerInput = undefined; 18 18 19 19 export interface HandlerError { 20 20 - status: number 21 21 - message?: string 20 20 + status: number; 21 21 + message?: string; 22 22 } 23 23 24 24 - export type HandlerOutput = HandlerError | void 24 24 + export type HandlerOutput = HandlerError | void; 25 25 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 26 26 - auth: HA 27 27 - params: QueryParams 28 28 - input: HandlerInput 29 29 - req: express.Request 30 30 - res: express.Response 31 31 - resetRouteRateLimits: () => Promise<void> 32 32 - } 26 26 + auth: HA; 27 27 + params: QueryParams; 28 28 + input: HandlerInput; 29 29 + req: express.Request; 30 30 + res: express.Response; 31 31 + resetRouteRateLimits: () => Promise<void>; 32 32 + }; 33 33 export type Handler<HA extends HandlerAuth = never> = ( 34 34 ctx: HandlerReqCtx<HA>, 35 35 - ) => Promise<HandlerOutput> | HandlerOutput 35 35 + ) => Promise<HandlerOutput> | HandlerOutput;

+14 -14

apps/api/src/lexicon/types/app/rocksky/stats/defs.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface StatsView { 10 10 /** The total number of scrobbles. */ 11 11 - scrobbles?: number 11 11 + scrobbles?: number; 12 12 /** The total number of unique artists scrobbled. */ 13 13 - artists?: number 13 13 + artists?: number; 14 14 /** The total number of tracks marked as loved. */ 15 15 - lovedTracks?: number 15 15 + lovedTracks?: number; 16 16 /** The total number of unique albums scrobbled. */ 17 17 - albums?: number 17 17 + albums?: number; 18 18 /** The total number of unique tracks scrobbled. */ 19 19 - tracks?: number 20 20 - [k: string]: unknown 19 19 + tracks?: number; 20 20 + [k: string]: unknown; 21 21 } 22 22 23 23 export function isStatsView(v: unknown): v is StatsView { 24 24 return ( 25 25 isObj(v) && 26 26 - hasProp(v, '$type') && 27 27 - v.$type === 'app.rocksky.stats.defs#statsView' 28 28 - ) 26 26 + hasProp(v, "$type") && 27 27 + v.$type === "app.rocksky.stats.defs#statsView" 28 28 + ); 29 29 } 30 30 31 31 export function validateStatsView(v: unknown): ValidationResult { 32 32 - return lexicons.validate('app.rocksky.stats.defs#statsView', v) 32 32 + return lexicons.validate("app.rocksky.stats.defs#statsView", v); 33 33 }

+25 -25

apps/api/src/lexicon/types/app/rocksky/stats/getStats.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import type express from 'express' 5 5 - import { ValidationResult, BlobRef } from '@atproto/lexicon' 6 6 - import { lexicons } from '../../../../lexicons' 7 7 - import { isObj, hasProp } from '../../../../util' 8 8 - import { CID } from 'multiformats/cid' 9 9 - import type { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server' 10 10 - import type * as AppRockskyStatsDefs from './defs' 4 4 + import express from "express"; 5 5 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 + import { lexicons } from "../../../../lexicons"; 7 7 + import { isObj, hasProp } from "../../../../util"; 8 8 + import { CID } from "multiformats/cid"; 9 9 + import { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 + import * as AppRockskyStatsDefs from "./defs"; 11 11 12 12 export interface QueryParams { 13 13 /** The DID or handle of the user to get stats for. */ 14 14 - did: string 14 14 + did: string; 15 15 } 16 16 17 17 - export type InputSchema = undefined 18 18 - export type OutputSchema = AppRockskyStatsDefs.StatsView 19 19 - export type HandlerInput = undefined 17 17 + export type InputSchema = undefined; 18 18 + export type OutputSchema = AppRockskyStatsDefs.StatsView; 19 19 + export type HandlerInput = undefined; 20 20 21 21 export interface HandlerSuccess { 22 22 - encoding: 'application/json' 23 23 - body: OutputSchema 24 24 - headers?: { [key: string]: string } 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 } 26 26 27 27 export interface HandlerError { 28 28 - status: number 29 29 - message?: string 28 28 + status: number; 29 29 + message?: string; 30 30 } 31 31 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough 32 32 + export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA 35 35 - params: QueryParams 36 36 - input: HandlerInput 37 37 - req: express.Request 38 38 - res: express.Response 39 39 - resetRouteRateLimits: () => Promise<void> 40 40 - } 34 34 + auth: HA; 35 35 + params: QueryParams; 36 36 + input: HandlerInput; 37 37 + req: express.Request; 38 38 + res: express.Response; 39 39 + resetRouteRateLimits: () => Promise<void>; 40 40 + }; 41 41 export type Handler<HA extends HandlerAuth = never> = ( 42 42 ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput 43 43 + ) => Promise<HandlerOutput> | HandlerOutput;

+12 -12

apps/api/src/lexicon/types/com/atproto/repo/strongRef.ts

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 - import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 - import { lexicons } from '../../../../lexicons' 6 6 - import { isObj, hasProp } from '../../../../util' 7 7 - import { CID } from 'multiformats/cid' 4 4 + import { ValidationResult, BlobRef } from "@atproto/lexicon"; 5 5 + import { lexicons } from "../../../../lexicons"; 6 6 + import { isObj, hasProp } from "../../../../util"; 7 7 + import { CID } from "multiformats/cid"; 8 8 9 9 export interface Main { 10 10 - uri: string 11 11 - cid: string 12 12 - [k: string]: unknown 10 10 + uri: string; 11 11 + cid: string; 12 12 + [k: string]: unknown; 13 13 } 14 14 15 15 export function isMain(v: unknown): v is Main { 16 16 return ( 17 17 isObj(v) && 18 18 - hasProp(v, '$type') && 19 19 - (v.$type === 'com.atproto.repo.strongRef#main' || 20 20 - v.$type === 'com.atproto.repo.strongRef') 21 21 - ) 18 18 + hasProp(v, "$type") && 19 19 + (v.$type === "com.atproto.repo.strongRef#main" || 20 20 + v.$type === "com.atproto.repo.strongRef") 21 21 + ); 22 22 } 23 23 24 24 export function validateMain(v: unknown): ValidationResult { 25 25 - return lexicons.validate('com.atproto.repo.strongRef#main', v) 25 25 + return lexicons.validate("com.atproto.repo.strongRef#main", v); 26 26 }

+2 -2

apps/api/src/lexicon/util.ts

··· 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 export function isObj(v: unknown): v is Record<string, unknown> { 5 5 - return typeof v === 'object' && v !== null 5 5 + return typeof v === "object" && v !== null; 6 6 } 7 7 8 8 export function hasProp<K extends PropertyKey>( 9 9 data: object, 10 10 prop: K, 11 11 ): data is Record<K, unknown> { 12 12 - return prop in data 12 12 + return prop in data; 13 13 }

+32 -32

apps/api/src/nowplaying/nowplaying.service.ts

··· 14 14 15 15 export async function putArtistRecord( 16 16 track: Track, 17 17 - agent: Agent 17 17 + agent: Agent, 18 18 ): Promise<string | null> { 19 19 const rkey = TID.nextStr(); 20 20 const record: { ··· 63 63 64 64 export async function putAlbumRecord( 65 65 track: Track, 66 66 - agent: Agent 66 66 + agent: Agent, 67 67 ): Promise<string | null> { 68 68 const rkey = TID.nextStr(); 69 69 let albumArt; ··· 123 123 124 124 export async function putSongRecord( 125 125 track: Track, 126 126 - agent: Agent 126 126 + agent: Agent, 127 127 ): Promise<string | null> { 128 128 const rkey = TID.nextStr(); 129 129 let albumArt; ··· 191 191 192 192 async function putScrobbleRecord( 193 193 track: Track, 194 194 - agent: Agent 194 194 + agent: Agent, 195 195 ): Promise<string | null> { 196 196 const rkey = TID.nextStr(); 197 197 let albumArt; ··· 369 369 ctx: Context, 370 370 track: Track, 371 371 agent: Agent, 372 372 - userDid: string 372 372 + userDid: string, 373 373 ): Promise<void> { 374 374 // check if scrobble already exists (user did + timestamp) 375 375 const scrobbleTime = dayjs.unix(track.timestamp); ··· 393 393 if (existingScrobble) { 394 394 console.log( 395 395 `Scrobble already exists for ${chalk.cyan(track.title)} at ${chalk.cyan( 396 396 - dayjs.unix(track.timestamp).format("YYYY-MM-DD HH:mm:ss") 397 397 - )}` 396 396 + dayjs.unix(track.timestamp).format("YYYY-MM-DD HH:mm:ss"), 397 397 + )}`, 398 398 ); 399 399 return; 400 400 } ··· 406 406 equals( 407 407 createHash("sha256") 408 408 .update( 409 409 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 409 409 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 410 410 ) 411 411 - .digest("hex") 412 412 - ) 411 411 + .digest("hex"), 412 412 + ), 413 413 ) 414 414 .getFirst(); 415 415 ··· 420 420 equals( 421 421 createHash("sha256") 422 422 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 423 423 - .digest("hex") 424 424 - ) 423 423 + .digest("hex"), 424 424 + ), 425 425 ) 426 426 .getFirst(); 427 427 if (album) { ··· 438 438 equals( 439 439 createHash("sha256") 440 440 .update(track.albumArtist.toLowerCase()) 441 441 - .digest("hex") 442 442 - ) 441 441 + .digest("hex"), 442 442 + ), 443 443 ) 444 444 .getFirst(); 445 445 if (artist) { ··· 466 466 equals( 467 467 createHash("sha256") 468 468 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 469 469 - .digest("hex") 470 470 - ) 469 469 + .digest("hex"), 470 470 + ), 471 471 ) 472 472 .getFirst(); 473 473 ··· 480 480 equals( 481 481 createHash("sha256") 482 482 .update( 483 483 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 483 483 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 484 484 ) 485 485 - .digest("hex") 486 486 - ) 485 485 + .digest("hex"), 486 486 + ), 487 487 ) 488 488 .getFirst(); 489 489 await new Promise((resolve) => setTimeout(resolve, 1000)); ··· 496 496 497 497 if (existingTrack) { 498 498 console.log( 499 499 - `Song found: ${chalk.cyan(existingTrack.xata_id)} - ${track.title}, after ${chalk.magenta(tries)} tries` 499 499 + `Song found: ${chalk.cyan(existingTrack.xata_id)} - ${track.title}, after ${chalk.magenta(tries)} tries`, 500 500 ); 501 501 } 502 502 ··· 546 546 equals( 547 547 createHash("sha256") 548 548 .update( 549 549 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 549 549 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 550 550 ) 551 551 - .digest("hex") 552 552 - ) 551 551 + .digest("hex"), 552 552 + ), 553 553 ) 554 554 .getFirst(); 555 555 ··· 559 559 tries < 30 560 560 ) { 561 561 console.log( 562 562 - `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}` 562 562 + `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}`, 563 563 ); 564 564 existingTrack = await ctx.client.db.tracks 565 565 .filter( ··· 567 567 equals( 568 568 createHash("sha256") 569 569 .update( 570 570 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 570 570 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 571 571 ) 572 572 - .digest("hex") 573 573 - ) 572 572 + .digest("hex"), 573 573 + ), 574 574 ) 575 575 .getFirst(); 576 576 ··· 582 582 equals( 583 583 createHash("sha256") 584 584 .update(track.albumArtist.toLowerCase()) 585 585 - .digest("hex") 586 586 - ) 585 585 + .digest("hex"), 586 586 + ), 587 587 ) 588 588 .getFirst(); 589 589 if (artist) { ··· 602 602 equals( 603 603 createHash("sha256") 604 604 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 605 605 - .digest("hex") 606 606 - ) 605 605 + .digest("hex"), 606 606 + ), 607 607 ) 608 608 .getFirst(); 609 609 if (album) { ··· 630 630 631 631 if (existingTrack?.artist_uri) { 632 632 console.log( 633 633 - `Artist uri ready: ${chalk.cyan(existingTrack.xata_id)} - ${track.title}, after ${chalk.magenta(tries)} tries` 633 633 + `Artist uri ready: ${chalk.cyan(existingTrack.xata_id)} - ${track.title}, after ${chalk.magenta(tries)} tries`, 634 634 ); 635 635 } 636 636

+3 -3

apps/api/src/scripts/genres.ts

··· 11 11 .from(tables.spotifyTokens) 12 12 .leftJoin( 13 13 tables.spotifyAccounts, 14 14 - eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId) 14 14 + eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId), 15 15 ) 16 16 .where(eq(tables.spotifyAccounts.isBetaUser, true)) 17 17 .execute() ··· 51 51 headers: { 52 52 Authorization: `Bearer ${token}`, 53 53 }, 54 54 - } 54 54 + }, 55 55 ) 56 56 .then( 57 57 (res) => ··· 64 64 images: Array<{ url: string }>; 65 65 }>; 66 66 }; 67 67 - }> 67 67 + }>, 68 68 ) 69 69 .then(async (data) => _.get(data, "artists.items.0")); 70 70

+11 -11

apps/api/src/scripts/sync.ts

··· 25 25 equals( 26 26 createHash("sha256") 27 27 .update( 28 28 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 28 28 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 29 29 ) 30 30 - .digest("hex") 31 31 - ) 30 30 + .digest("hex"), 31 31 + ), 32 32 ) 33 33 .getFirst(); 34 34 ··· 40 40 equals( 41 41 createHash("sha256") 42 42 .update(`${track.album} - ${track.album_artist}`.toLowerCase()) 43 43 - .digest("hex") 44 44 - ) 43 43 + .digest("hex"), 44 44 + ), 45 45 ) 46 46 .getFirst(); 47 47 if (album) { ··· 59 59 equals( 60 60 createHash("sha256") 61 61 .update(track.album_artist.toLowerCase()) 62 62 - .digest("hex") 63 63 - ) 62 62 + .digest("hex"), 63 63 + ), 64 64 ) 65 65 .getFirst(); 66 66 if (artist) { ··· 76 76 equals( 77 77 createHash("sha256") 78 78 .update(`${track.album} - ${track.album_artist}`.toLowerCase()) 79 79 - .digest("hex") 80 80 - ) 79 79 + .digest("hex"), 80 80 + ), 81 81 ) 82 82 .getFirst(); 83 83 ··· 89 89 equals( 90 90 createHash("sha256") 91 91 .update(track.album_artist.toLowerCase()) 92 92 - .digest("hex") 93 93 - ) 92 92 + .digest("hex"), 93 93 + ), 94 94 ) 95 95 .getFirst(); 96 96 if (artist) {

+9 -9

apps/api/src/xrpc/app/rocksky/actor/getProfile.ts

··· 33 33 Effect.catchAll((err) => { 34 34 console.error(err); 35 35 return Effect.succeed({}); 36 36 - }) 36 36 + }), 37 37 ); 38 38 server.app.rocksky.actor.getProfile({ 39 39 auth: ctx.authVerifier, ··· 192 192 .from(tables.spotifyAccounts) 193 193 .leftJoin( 194 194 tables.users, 195 195 - eq(tables.spotifyAccounts.userId, tables.users.id) 195 195 + eq(tables.spotifyAccounts.userId, tables.users.id), 196 196 ) 197 197 .where(eq(tables.users.did, did)) 198 198 .execute() ··· 202 202 .from(tables.spotifyTokens) 203 203 .leftJoin( 204 204 tables.users, 205 205 - eq(tables.spotifyTokens.userId, tables.users.id) 205 205 + eq(tables.spotifyTokens.userId, tables.users.id), 206 206 ) 207 207 .where(eq(tables.users.did, did)) 208 208 .execute() ··· 212 212 .from(tables.googleDriveAccounts) 213 213 .leftJoin( 214 214 tables.users, 215 215 - eq(tables.googleDriveAccounts.userId, tables.users.id) 215 215 + eq(tables.googleDriveAccounts.userId, tables.users.id), 216 216 ) 217 217 .where(eq(tables.users.did, did)) 218 218 .execute() ··· 222 222 .from(tables.dropboxAccounts) 223 223 .leftJoin( 224 224 tables.users, 225 225 - eq(tables.dropboxAccounts.userId, tables.users.id) 225 225 + eq(tables.dropboxAccounts.userId, tables.users.id), 226 226 ) 227 227 .where(eq(tables.users.did, did)) 228 228 .execute() ··· 279 279 xata_createdat: profile.user.createdAt.toISOString(), 280 280 xata_updatedat: profile.user.updatedAt.toISOString(), 281 281 xata_version: 1, 282 282 - }) 283 283 - ) 282 282 + }), 283 283 + ), 284 284 ); 285 285 } else { 286 286 // Update existing user in background if handle or avatar or displayName changed ··· 313 313 xata_createdat: profile.user.createdAt.toISOString(), 314 314 xata_updatedat: new Date().toISOString(), 315 315 xata_version: (profile.user.xataVersion || 1) + 1, 316 316 - }) 317 317 - ) 316 316 + }), 317 317 + ), 318 318 ); 319 319 } 320 320 }

+1 -1

apps/api/src/xrpc/app/rocksky/artist/getArtistListeners.ts

··· 15 15 Effect.catchAll((err) => { 16 16 console.error(err); 17 17 return Effect.succeed({ listeners: [] }); 18 18 - }) 18 18 + }), 19 19 ); 20 20 server.app.rocksky.artist.getArtistListeners({ 21 21 handler: async ({ params }) => {

+182 -182

apps/api/src/xrpc/app/rocksky/scrobble/createScrobble.ts

··· 38 38 pipe( 39 39 scrobbleTrack(ctx, track, agent, did), 40 40 Effect.tap(() => 41 41 - Effect.logInfo(`Scrobble created for ${chalk.cyan(track.title)}`) 42 42 - ) 43 43 - ) 41 41 + Effect.logInfo(`Scrobble created for ${chalk.cyan(track.title)}`), 42 42 + ), 43 43 + ), 44 44 ), 45 45 Effect.flatMap(presentation), 46 46 Effect.retry({ times: 3 }), ··· 48 48 Effect.catchAll((err) => { 49 49 console.error(err); 50 50 return Effect.succeed({}); 51 51 - }) 51 51 + }), 52 52 ); 53 53 server.app.rocksky.scrobble.createScrobble({ 54 54 auth: ctx.authVerifier, ··· 82 82 ctx, 83 83 did, 84 84 input, 85 85 - })) 85 85 + })), 86 86 ), 87 87 Match.orElse(() => { 88 88 throw new Error("Authentication required to create a scrobble"); 89 89 - }) 89 89 + }), 90 90 ), 91 91 catch: (error) => new Error(`Failed to create agent: ${error}`), 92 92 }); ··· 138 138 Effect.flatMap(([imageBuffer, options]) => 139 139 pipe( 140 140 Effect.tryPromise(() => agent.uploadBlob(imageBuffer, options)), 141 141 - Effect.map((uploadResponse) => uploadResponse.data.blob) 142 142 - ) 141 141 + Effect.map((uploadResponse) => uploadResponse.data.blob), 142 142 + ), 143 143 ), 144 144 - Effect.catchAll(() => Effect.succeed(undefined as BlobRef | undefined)) 144 144 + Effect.catchAll(() => Effect.succeed(undefined as BlobRef | undefined)), 145 145 ); 146 146 147 147 const putRecord = <T>( 148 148 agent: Agent, 149 149 collection: string, 150 150 record: T, 151 151 - validate: (record: T) => { success: boolean } 151 151 + validate: (record: T) => { success: boolean }, 152 152 ) => 153 153 pipe( 154 154 Effect.succeed(record), 155 155 Effect.filterOrFail( 156 156 (rec) => validate(rec).success, 157 157 - () => new Error("Invalid record") 157 157 + () => new Error("Invalid record"), 158 158 ), 159 159 Effect.flatMap(() => 160 160 pipe( ··· 167 167 rkey, 168 168 record, 169 169 validate: false, 170 170 - }) 171 171 - ) 170 170 + }), 171 171 + ), 172 172 ), 173 173 Effect.tap((res) => 174 174 - Effect.logInfo(`Record created at ${res.data.uri}`) 174 174 + Effect.logInfo(`Record created at ${res.data.uri}`), 175 175 ), 176 176 - Effect.map((res) => res.data.uri) 177 177 - ) 176 176 + Effect.map((res) => res.data.uri), 177 177 + ), 178 178 ), 179 179 Effect.catchAll((error) => { 180 180 console.error(`Error creating ${collection} record`, error); 181 181 return Effect.succeed(null); 182 182 - }) 182 182 + }), 183 183 ); 184 184 185 185 const putArtistRecord = (track: Track, agent: Agent) => ··· 195 195 tags: track.genres, 196 196 })), 197 197 Effect.flatMap((record) => 198 198 - putRecord(agent, "app.rocksky.artist", record, Artist.validateRecord) 199 199 - ) 198 198 + putRecord(agent, "app.rocksky.artist", record, Artist.validateRecord), 199 199 + ), 200 200 ); 201 201 202 202 const putAlbumRecord = (track: Track, agent: Agent) => ··· 204 204 Match.value(track.albumArt).pipe( 205 205 Match.when( 206 206 (url) => !!url, 207 207 - (url) => uploadImage(url, agent) 207 207 + (url) => uploadImage(url, agent), 208 208 ), 209 209 - Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)) 209 209 + Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)), 210 210 ), 211 211 Effect.map((albumArt) => ({ 212 212 $type: "app.rocksky.album", ··· 220 220 albumArt, 221 221 })), 222 222 Effect.flatMap((record) => 223 223 - putRecord(agent, "app.rocksky.album", record, Album.validateRecord) 224 224 - ) 223 223 + putRecord(agent, "app.rocksky.album", record, Album.validateRecord), 224 224 + ), 225 225 ); 226 226 227 227 const putSongRecord = (track: Track, agent: Agent) => ··· 229 229 Match.value(track.albumArt).pipe( 230 230 Match.when( 231 231 (url) => !!url, 232 232 - (url) => uploadImage(url, agent) 232 232 + (url) => uploadImage(url, agent), 233 233 ), 234 234 - Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)) 234 234 + Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)), 235 235 ), 236 236 Effect.map((albumArt) => ({ 237 237 $type: "app.rocksky.song", ··· 254 254 spotifyLink: track.spotifyLink ?? undefined, 255 255 })), 256 256 Effect.flatMap((record) => 257 257 - putRecord(agent, "app.rocksky.song", record, Song.validateRecord) 258 258 - ) 257 257 + putRecord(agent, "app.rocksky.song", record, Song.validateRecord), 258 258 + ), 259 259 ); 260 260 261 261 const putScrobbleRecord = (track: Track, agent: Agent) => ··· 263 263 Match.value(track.albumArt).pipe( 264 264 Match.when( 265 265 (url) => !!url, 266 266 - (url) => uploadImage(url, agent) 266 266 + (url) => uploadImage(url, agent), 267 267 ), 268 268 - Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)) 268 268 + Match.orElse(() => Effect.succeed(undefined as BlobRef | undefined)), 269 269 ), 270 270 Effect.map((albumArt) => ({ 271 271 $type: "app.rocksky.scrobble", ··· 290 290 spotifyLink: track.spotifyLink ?? undefined, 291 291 })), 292 292 Effect.flatMap((record) => 293 293 - putRecord(agent, "app.rocksky.scrobble", record, Scrobble.validateRecord) 294 294 - ) 293 293 + putRecord(agent, "app.rocksky.scrobble", record, Scrobble.validateRecord), 294 294 + ), 295 295 ); 296 296 297 297 const getScrobble = ({ ctx, id }: { ctx: Context; id: string }) => ··· 303 303 .leftJoin(tables.albums, eq(tables.albums.id, tables.scrobbles.albumId)) 304 304 .leftJoin( 305 305 tables.artists, 306 306 - eq(tables.artists.id, tables.scrobbles.artistId) 306 306 + eq(tables.artists.id, tables.scrobbles.artistId), 307 307 ) 308 308 .leftJoin(tables.users, eq(tables.users.id, tables.scrobbles.userId)) 309 309 .where(eq(tables.scrobbles.id, id)) 310 310 .execute() 311 311 - .then(([row]) => row) 311 311 + .then(([row]) => row), 312 312 ); 313 313 314 314 const getUserAlbum = ( ··· 318 318 artists: SelectArtist; 319 319 users: SelectUser; 320 320 tracks: SelectTrack; 321 321 - } 321 321 + }, 322 322 ) => 323 323 Effect.tryPromise(() => 324 324 ctx.db ··· 326 326 .from(tables.userAlbums) 327 327 .where(eq(tables.userAlbums.albumId, scrobble.albums.id)) 328 328 .execute() 329 329 - .then(([row]) => row) 329 329 + .then(([row]) => row), 330 330 ); 331 331 332 332 const getUserArtist = ( ··· 336 336 artists: SelectArtist; 337 337 users: SelectUser; 338 338 tracks: SelectTrack; 339 339 - } 339 339 + }, 340 340 ) => 341 341 Effect.tryPromise(() => 342 342 ctx.db ··· 344 344 .from(tables.userArtists) 345 345 .where(eq(tables.userArtists.id, scrobble.artists.id)) 346 346 .execute() 347 347 - .then(([row]) => row) 347 347 + .then(([row]) => row), 348 348 ); 349 349 350 350 const getUserTrack = ( ··· 354 354 artists: SelectArtist; 355 355 users: SelectUser; 356 356 tracks: SelectTrack; 357 357 - } 357 357 + }, 358 358 ) => 359 359 Effect.tryPromise(() => 360 360 ctx.db ··· 362 362 .from(tables.userTracks) 363 363 .where(eq(tables.userTracks.id, scrobble.tracks.id)) 364 364 .execute() 365 365 - .then(([row]) => row) 365 365 + .then(([row]) => row), 366 366 ); 367 367 368 368 const getAlbumTrack = ( ··· 372 372 artists: SelectArtist; 373 373 users: SelectUser; 374 374 tracks: SelectTrack; 375 375 - } 375 375 + }, 376 376 ) => 377 377 Effect.tryPromise(() => 378 378 ctx.db ··· 380 380 .from(tables.albumTracks) 381 381 .where(eq(tables.albumTracks.trackId, scrobble.tracks.id)) 382 382 .execute() 383 383 - .then(([row]) => row) 383 383 + .then(([row]) => row), 384 384 ); 385 385 386 386 const getArtistTrack = ( ··· 390 390 artists: SelectArtist; 391 391 users: SelectUser; 392 392 tracks: SelectTrack; 393 393 - } 393 393 + }, 394 394 ) => 395 395 Effect.tryPromise(() => 396 396 ctx.db ··· 398 398 .from(tables.artistTracks) 399 399 .where(eq(tables.artistTracks.trackId, scrobble.tracks.id)) 400 400 .execute() 401 401 - .then(([row]) => row) 401 401 + .then(([row]) => row), 402 402 ); 403 403 404 404 const getArtistAlbum = ( ··· 408 408 artists: SelectArtist; 409 409 users: SelectUser; 410 410 tracks: SelectTrack; 411 411 - } 411 411 + }, 412 412 ) => 413 413 Effect.tryPromise(() => 414 414 ctx.db ··· 417 417 .where( 418 418 and( 419 419 eq(tables.artistAlbums.albumId, scrobble.albums.id), 420 420 - eq(tables.artistAlbums.artistId, scrobble.artists.id) 421 421 - ) 420 420 + eq(tables.artistAlbums.artistId, scrobble.artists.id), 421 421 + ), 422 422 ) 423 423 - .then(([row]) => row) 423 423 + .then(([row]) => row), 424 424 ); 425 425 426 426 const createUserArtist = ( ··· 430 430 artists: SelectArtist; 431 431 users: SelectUser; 432 432 tracks: SelectTrack; 433 433 - } 433 433 + }, 434 434 ) => 435 435 pipe( 436 436 Effect.tryPromise(() => ··· 442 442 uri: scrobble.artists.uri, 443 443 scrobbles: 1, 444 444 } as InsertUserArtist) 445 445 - .execute() 445 445 + .execute(), 446 446 ), 447 447 Effect.flatMap(() => 448 448 Effect.tryPromise(() => ··· 451 451 .from(tables.userArtists) 452 452 .where(eq(tables.userArtists.artistId, scrobble.artists.id)) 453 453 .execute() 454 454 - .then(([row]) => row) 455 455 - ) 456 456 - ) 454 454 + .then(([row]) => row), 455 455 + ), 456 456 + ), 457 457 ); 458 458 459 459 const createUserAlbum = ( ··· 463 463 artists: SelectArtist; 464 464 users: SelectUser; 465 465 tracks: SelectTrack; 466 466 - } 466 466 + }, 467 467 ) => 468 468 pipe( 469 469 Effect.tryPromise(() => ··· 475 475 uri: scrobble.albums.uri, 476 476 scrobbles: 1, 477 477 } as InsertUserAlbum) 478 478 - .execute() 478 478 + .execute(), 479 479 ), 480 480 Effect.flatMap(() => 481 481 Effect.tryPromise(() => ··· 484 484 .from(tables.userAlbums) 485 485 .where(eq(tables.userAlbums.albumId, scrobble.albums.id)) 486 486 .execute() 487 487 - .then(([row]) => row) 488 488 - ) 489 489 - ) 487 487 + .then(([row]) => row), 488 488 + ), 489 489 + ), 490 490 ); 491 491 492 492 const createUserTrack = ( ··· 496 496 artists: SelectArtist; 497 497 users: SelectUser; 498 498 tracks: SelectTrack; 499 499 - } 499 499 + }, 500 500 ) => 501 501 pipe( 502 502 Effect.tryPromise(() => ··· 508 508 uri: scrobble.tracks.uri, 509 509 scrobbles: 1, 510 510 } as InsertUserTrack) 511 511 - .execute() 511 511 + .execute(), 512 512 ), 513 513 Effect.flatMap(() => 514 514 Effect.tryPromise(() => ··· 516 516 .select() 517 517 .from(tables.userTracks) 518 518 .where(eq(tables.userTracks.trackId, scrobble.tracks.id)) 519 519 - .then(([row]) => row) 520 520 - ) 521 521 - ) 519 519 + .then(([row]) => row), 520 520 + ), 521 521 + ), 522 522 ); 523 523 524 524 const publishScrobble = (ctx: Context, id: string) => ··· 689 689 xata_updatedat: artistAlbum.updatedAt.toISOString(), 690 690 xata_version: artistAlbum.xataVersion, 691 691 }, 692 692 - }) 693 693 - ) 694 694 - ) 695 695 - ) 696 696 - ) 692 692 + }), 693 693 + ), 694 694 + ), 695 695 + ), 696 696 + ), 697 697 ), 698 698 Effect.flatMap((data) => 699 699 Effect.try(() => 700 700 ctx.nc.publish( 701 701 "rocksky.scrobble", 702 702 Buffer.from( 703 703 - JSON.stringify(data).replaceAll("sha_256", "sha256") 704 704 - ) 705 705 - ) 706 706 - ) 707 707 - ) 708 708 - ) 709 709 - ) 710 710 - ) 711 711 - ) 703 703 + JSON.stringify(data).replaceAll("sha_256", "sha256"), 704 704 + ), 705 705 + ), 706 706 + ), 707 707 + ), 708 708 + ), 709 709 + ), 710 710 + ), 711 711 + ), 712 712 ); 713 713 714 714 const computeTrackHash = (track: Track): Effect.Effect<string, never> => 715 715 Effect.succeed( 716 716 createHash("sha256") 717 717 .update(`${track.title} - ${track.artist} - ${track.album}`.toLowerCase()) 718 718 - .digest("hex") 718 718 + .digest("hex"), 719 719 ); 720 720 721 721 const computeAlbumHash = (track: Track): Effect.Effect<string, never> => 722 722 Effect.succeed( 723 723 createHash("sha256") 724 724 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 725 725 - .digest("hex") 725 725 + .digest("hex"), 726 726 ); 727 727 728 728 const computeArtistHash = (track: Track): Effect.Effect<string, never> => 729 729 Effect.succeed( 730 730 - createHash("sha256").update(track.albumArtist.toLowerCase()).digest("hex") 730 730 + createHash("sha256").update(track.albumArtist.toLowerCase()).digest("hex"), 731 731 ); 732 732 733 733 const fetchExistingTrack = ( 734 734 ctx: Context, 735 735 - trackHash: string 735 735 + trackHash: string, 736 736 ): Effect.Effect<SelectTrack | undefined, Error> => 737 737 Effect.tryPromise(() => 738 738 ctx.db ··· 740 740 .from(tables.tracks) 741 741 .where(eq(tables.tracks.sha256, trackHash)) 742 742 .execute() 743 743 - .then(([row]) => row) 743 743 + .then(([row]) => row), 744 744 ); 745 745 746 746 // Update track metadata (album_uri and artist_uri) 747 747 const updateTrackMetadata = ( 748 748 ctx: Context, 749 749 track: Track, 750 750 - trackRecord: SelectTrack 750 750 + trackRecord: SelectTrack, 751 751 ) => 752 752 pipe( 753 753 Effect.succeed(trackRecord), ··· 762 762 .from(tables.albums) 763 763 .where(eq(tables.albums.sha256, albumHash)) 764 764 .execute() 765 765 - .then(([row]) => row) 766 766 - ) 765 765 + .then(([row]) => row), 766 766 + ), 767 767 ), 768 768 Effect.flatMap((album) => 769 769 album ··· 774 774 albumUri: album.uri, 775 775 }) 776 776 .where(eq(tables.tracks.id, trackRecord.id)) 777 777 - .execute() 777 777 + .execute(), 778 778 ) 779 779 - : Effect.succeed(undefined) 780 780 - ) 779 779 + : Effect.succeed(undefined), 780 780 + ), 781 781 ) 782 782 - : Effect.succeed(undefined) 782 782 + : Effect.succeed(undefined), 783 783 ), 784 784 Effect.tap((trackRecord) => 785 785 !trackRecord.artistUri ··· 792 792 .from(tables.artists) 793 793 .where(eq(tables.artists.sha256, artistHash)) 794 794 .execute() 795 795 - .then(([row]) => row) 796 796 - ) 795 795 + .then(([row]) => row), 796 796 + ), 797 797 ), 798 798 Effect.flatMap((artist) => 799 799 artist ··· 804 804 artistUri: artist.uri, 805 805 }) 806 806 .where(eq(tables.tracks.id, trackRecord.id)) 807 807 - .execute() 807 807 + .execute(), 808 808 ) 809 809 - : Effect.succeed(undefined) 810 810 - ) 809 809 + : Effect.succeed(undefined), 810 810 + ), 811 811 ) 812 812 - : Effect.succeed(undefined) 813 813 - ) 812 812 + : Effect.succeed(undefined), 813 813 + ), 814 814 ); 815 815 816 816 // Ensure track exists or create it ··· 819 819 track: Track, 820 820 agent: Agent, 821 821 userDid: string, 822 822 - existingTrack: SelectTrack | undefined 822 822 + existingTrack: SelectTrack | undefined, 823 823 ) => 824 824 pipe( 825 825 Effect.succeed(existingTrack), ··· 827 827 Match.value(trackOpt).pipe( 828 828 Match.when( 829 829 (value) => !!value, 830 830 - () => updateTrackMetadata(ctx, track, trackOpt) 830 830 + () => updateTrackMetadata(ctx, track, trackOpt), 831 831 ), 832 832 - Match.orElse(() => Effect.succeed(undefined)) 833 833 - ) 832 832 + Match.orElse(() => Effect.succeed(undefined)), 833 833 + ), 834 834 ), 835 835 Effect.flatMap((trackOpt) => 836 836 pipe( ··· 840 840 .from(tables.userTracks) 841 841 .leftJoin( 842 842 tables.tracks, 843 843 - eq(tables.userTracks.trackId, tables.tracks.id) 843 843 + eq(tables.userTracks.trackId, tables.tracks.id), 844 844 ) 845 845 .leftJoin( 846 846 tables.users, 847 847 - eq(tables.userTracks.userId, tables.users.id) 847 847 + eq(tables.userTracks.userId, tables.users.id), 848 848 ) 849 849 .where( 850 850 and( 851 851 eq(tables.tracks.id, trackOpt?.id), 852 852 - eq(tables.users.did, userDid) 853 853 - ) 852 852 + eq(tables.users.did, userDid), 853 853 + ), 854 854 ) 855 855 .execute() 856 856 - .then(([row]) => row.user_tracks) 856 856 + .then(([row]) => row.user_tracks), 857 857 ), 858 858 Effect.flatMap((userTrack) => 859 859 Option.isNone(Option.fromNullable(userTrack)) || 860 860 !userTrack?.uri?.includes(userDid) 861 861 ? putSongRecord(track, agent) 862 862 - : Effect.succeed(null) 863 863 - ) 864 864 - ) 865 865 - ) 862 862 + : Effect.succeed(null), 863 863 + ), 864 864 + ), 865 865 + ), 866 866 ); 867 867 868 868 // Ensure album exists or create it ··· 870 870 ctx: Context, 871 871 track: Track, 872 872 agent: Agent, 873 873 - userDid: string 873 873 + userDid: string, 874 874 ) => 875 875 pipe( 876 876 computeAlbumHash(track), ··· 881 881 .from(tables.albums) 882 882 .where(eq(tables.albums.sha256, albumHash)) 883 883 .execute() 884 884 - .then(([row]) => row) 885 885 - ) 884 884 + .then(([row]) => row), 885 885 + ), 886 886 ), 887 887 Effect.flatMap((existingAlbum) => 888 888 pipe( ··· 894 894 .from(tables.userAlbums) 895 895 .leftJoin( 896 896 tables.albums, 897 897 - eq(tables.userAlbums.albumId, tables.albums.id) 897 897 + eq(tables.userAlbums.albumId, tables.albums.id), 898 898 ) 899 899 .leftJoin( 900 900 tables.users, 901 901 - eq(tables.userAlbums.userId, tables.users.id) 901 901 + eq(tables.userAlbums.userId, tables.users.id), 902 902 ) 903 903 .where( 904 904 and( 905 905 eq(tables.albums.id, album.id), 906 906 - eq(tables.users.did, userDid) 907 907 - ) 906 906 + eq(tables.users.did, userDid), 907 907 + ), 908 908 ) 909 909 .execute() 910 910 - .then(([row]) => row.user_albums) 911 911 - ) 910 910 + .then(([row]) => row.user_albums), 911 911 + ), 912 912 ), 913 913 Effect.flatMap((userAlbum) => 914 914 Option.isNone(Option.fromNullable(existingAlbum)) || 915 915 Option.isNone(Option.fromNullable(userAlbum)) || 916 916 !userAlbum?.uri?.includes(userDid) 917 917 ? putAlbumRecord(track, agent) 918 918 - : Effect.succeed(null) 919 919 - ) 920 920 - ) 921 921 - ) 918 918 + : Effect.succeed(null), 919 919 + ), 920 920 + ), 921 921 + ), 922 922 ); 923 923 924 924 // Ensure artist exists or create it ··· 926 926 ctx: Context, 927 927 track: Track, 928 928 agent: Agent, 929 929 - userDid: string 929 929 + userDid: string, 930 930 ) => 931 931 pipe( 932 932 computeArtistHash(track), ··· 937 937 .from(tables.artists) 938 938 .where(eq(tables.artists.sha256, artistHash)) 939 939 .execute() 940 940 - .then(([row]) => row) 941 941 - ) 940 940 + .then(([row]) => row), 941 941 + ), 942 942 ), 943 943 Effect.flatMap((existingArtist) => 944 944 pipe( ··· 950 950 .from(tables.userArtists) 951 951 .leftJoin( 952 952 tables.artists, 953 953 - eq(tables.userArtists.artistId, tables.artists.id) 953 953 + eq(tables.userArtists.artistId, tables.artists.id), 954 954 ) 955 955 .leftJoin( 956 956 tables.users, 957 957 - eq(tables.userArtists.userId, tables.users.id) 957 957 + eq(tables.userArtists.userId, tables.users.id), 958 958 ) 959 959 .where( 960 960 and( 961 961 eq(tables.artists.id, artist.id), 962 962 - eq(tables.users.did, userDid) 963 963 - ) 962 962 + eq(tables.users.did, userDid), 963 963 + ), 964 964 ) 965 965 .execute() 966 966 - .then(([row]) => row.user_artists) 967 967 - ) 966 966 + .then(([row]) => row.user_artists), 967 967 + ), 968 968 ), 969 969 Effect.flatMap((userArtist) => 970 970 Effect.if( ··· 974 974 { 975 975 onTrue: () => putArtistRecord(track, agent), 976 976 onFalse: () => Effect.succeed(null), 977 977 - } 978 978 - ) 979 979 - ) 980 980 - ) 981 981 - ) 977 977 + }, 978 978 + ), 979 979 + ), 980 980 + ), 981 981 + ), 982 982 ); 983 983 984 984 // Retry fetching track until metadata is ready 985 985 const retryFetchTrack = ( 986 986 ctx: Context, 987 987 trackHash: string, 988 988 - initialTrack: SelectTrack | undefined 988 988 + initialTrack: SelectTrack | undefined, 989 989 ) => 990 990 pipe( 991 991 Effect.iterate( ··· 1001 1001 .from(tables.tracks) 1002 1002 .where(eq(tables.tracks.sha256, trackHash)) 1003 1003 .execute() 1004 1004 - .then(([row]) => row) 1004 1004 + .then(([row]) => row), 1005 1005 ), 1006 1006 Effect.flatMap((trackRecord) => 1007 1007 Option.fromNullable(trackRecord).pipe( 1008 1008 Effect.flatMap((track) => 1009 1009 - updateTrackMetadata(ctx, track, trackRecord) 1010 1010 - ) 1011 1011 - ) 1009 1009 + updateTrackMetadata(ctx, track, trackRecord), 1010 1010 + ), 1011 1011 + ), 1012 1012 ), 1013 1013 Effect.tap((trackRecord) => 1014 1014 Effect.logInfo( 1015 1015 trackRecord 1016 1016 ? `Track metadata ready: ${chalk.cyan(trackRecord.id)} - ${track.title}, after ${chalk.magenta(tries + 1)} tries` 1017 1017 - : `Retrying track fetch: ${chalk.magenta(tries + 1)}` 1018 1018 - ) 1017 1017 + : `Retrying track fetch: ${chalk.magenta(tries + 1)}`, 1018 1018 + ), 1019 1019 ), 1020 1020 Effect.map((trackRecord) => ({ 1021 1021 tries: tries + 1, 1022 1022 track: trackRecord, 1023 1023 })), 1024 1024 - Effect.delay("1 second") 1024 1024 + Effect.delay("1 second"), 1025 1025 ), 1026 1026 - } 1026 1026 + }, 1027 1027 ), 1028 1028 Effect.tap(({ tries, track }) => 1029 1029 tries >= 30 && !(track?.artistUri && track?.albumUri) 1030 1030 ? Effect.logError( 1031 1031 - `Track metadata not ready after ${chalk.magenta("30 tries")}` 1031 1031 + `Track metadata not ready after ${chalk.magenta("30 tries")}`, 1032 1032 ) 1033 1033 - : Effect.succeed(undefined) 1033 1033 + : Effect.succeed(undefined), 1034 1034 ), 1035 1035 - Effect.map(({ track }) => track) 1035 1035 + Effect.map(({ track }) => track), 1036 1036 ); 1037 1037 1038 1038 // Retry fetching scrobble until complete ··· 1070 1070 .from(tables.scrobbles) 1071 1071 .leftJoin( 1072 1072 tables.tracks, 1073 1073 - eq(tables.scrobbles.trackId, tables.tracks.id) 1073 1073 + eq(tables.scrobbles.trackId, tables.tracks.id), 1074 1074 ) 1075 1075 .leftJoin( 1076 1076 tables.albums, 1077 1077 - eq(tables.scrobbles.albumId, tables.albums.id) 1077 1077 + eq(tables.scrobbles.albumId, tables.albums.id), 1078 1078 ) 1079 1079 .leftJoin( 1080 1080 tables.artists, 1081 1081 - eq(tables.scrobbles.artistId, tables.artists.id) 1081 1081 + eq(tables.scrobbles.artistId, tables.artists.id), 1082 1082 ) 1083 1083 .leftJoin( 1084 1084 tables.users, 1085 1085 - eq(tables.scrobbles.userId, tables.users.id) 1085 1085 + eq(tables.scrobbles.userId, tables.users.id), 1086 1086 ) 1087 1087 .where(eq(tables.scrobbles.uri, scrobbleUri)) 1088 1088 .execute() 1089 1089 - .then(([row]) => row) 1089 1089 + .then(([row]) => row), 1090 1090 ), 1091 1091 Effect.tap((scrobble) => 1092 1092 Effect.if( ··· 1103 1103 artistUri: scrobble.artists.uri, 1104 1104 }) 1105 1105 .where(eq(tables.albums.id, scrobble.albums.id)) 1106 1106 - .execute() 1106 1106 + .execute(), 1107 1107 ), 1108 1108 onFalse: () => Effect.succeed(undefined), 1109 1109 - } 1110 1110 - ) 1109 1109 + }, 1110 1110 + ), 1111 1111 ), 1112 1112 Effect.flatMap(() => 1113 1113 Effect.tryPromise(() => ··· 1116 1116 .from(tables.scrobbles) 1117 1117 .leftJoin( 1118 1118 tables.tracks, 1119 1119 - eq(tables.scrobbles.trackId, tables.tracks.id) 1119 1119 + eq(tables.scrobbles.trackId, tables.tracks.id), 1120 1120 ) 1121 1121 .leftJoin( 1122 1122 tables.albums, 1123 1123 - eq(tables.scrobbles.albumId, tables.albums.id) 1123 1123 + eq(tables.scrobbles.albumId, tables.albums.id), 1124 1124 ) 1125 1125 .leftJoin( 1126 1126 tables.artists, 1127 1127 - eq(tables.scrobbles.artistId, tables.artists.id) 1127 1127 + eq(tables.scrobbles.artistId, tables.artists.id), 1128 1128 ) 1129 1129 .leftJoin( 1130 1130 tables.users, 1131 1131 - eq(tables.scrobbles.userId, tables.users.id) 1131 1131 + eq(tables.scrobbles.userId, tables.users.id), 1132 1132 ) 1133 1133 .where(eq(tables.scrobbles.uri, scrobbleUri)) 1134 1134 .execute() 1135 1135 - .then(([row]) => row) 1136 1136 - ) 1135 1135 + .then(([row]) => row), 1136 1136 + ), 1137 1137 ), 1138 1138 Effect.map((scrobble) => ({ 1139 1139 tries: tries + 1, ··· 1150 1150 scrobble.tracks.albumUri && 1151 1151 scrobble.scrobbles 1152 1152 ? `Scrobble found after ${chalk.magenta(tries + 1)} tries` 1153 1153 - : `Scrobble not found, trying again: ${chalk.magenta(tries + 1)}` 1154 1154 - ) 1153 1153 + : `Scrobble not found, trying again: ${chalk.magenta(tries + 1)}`, 1154 1154 + ), 1155 1155 ), 1156 1156 - Effect.delay("1 second") 1156 1156 + Effect.delay("1 second"), 1157 1157 ), 1158 1158 - } 1158 1158 + }, 1159 1159 ), 1160 1160 Effect.tap(({ tries, scrobble }) => 1161 1161 tries >= 30 && ··· 1169 1169 scrobble.tracks.albumUri 1170 1170 ) 1171 1171 ? Effect.logError( 1172 1172 - `Scrobble not found after ${chalk.magenta("30 tries")}` 1172 1172 + `Scrobble not found after ${chalk.magenta("30 tries")}`, 1173 1173 ) 1174 1174 - : Effect.succeed(undefined) 1174 1174 + : Effect.succeed(undefined), 1175 1175 ), 1176 1176 - Effect.map(({ scrobble }) => scrobble) 1176 1176 + Effect.map(({ scrobble }) => scrobble), 1177 1177 ); 1178 1178 1179 1179 export const scrobbleTrack = ( 1180 1180 ctx: Context, 1181 1181 track: Track, 1182 1182 agent: Agent, 1183 1183 - userDid: string 1183 1183 + userDid: string, 1184 1184 ) => 1185 1185 pipe( 1186 1186 computeTrackHash(track), ··· 1193 1193 Effect.flatMap(() => ensureAlbum(ctx, track, agent, userDid)), 1194 1194 Effect.flatMap(() => ensureArtist(ctx, track, agent, userDid)), 1195 1195 Effect.flatMap(() => 1196 1196 - retryFetchTrack(ctx, trackHash, existingTrack) 1196 1196 + retryFetchTrack(ctx, trackHash, existingTrack), 1197 1197 ), 1198 1198 Effect.flatMap(() => 1199 1199 pipe( ··· 1213 1213 ? pipe( 1214 1214 publishScrobble(ctx, scrobble.scrobbles.id), 1215 1215 Effect.tap(() => 1216 1216 - Effect.logInfo("Scrobble published") 1217 1217 - ) 1216 1216 + Effect.logInfo("Scrobble published"), 1217 1217 + ), 1218 1218 ) 1219 1219 - : Effect.succeed(undefined) 1220 1220 - ) 1221 1221 - ) 1222 1222 - ) 1223 1223 - ) 1224 1224 - ) 1225 1225 - ) 1226 1226 - ) 1227 1227 - ) 1228 1228 - ) 1219 1219 + : Effect.succeed(undefined), 1220 1220 + ), 1221 1221 + ), 1222 1222 + ), 1223 1223 + ), 1224 1224 + ), 1225 1225 + ), 1226 1226 + ), 1227 1227 + ), 1228 1228 + ), 1229 1229 );

+2 -2

apps/api/src/xrpc/app/rocksky/scrobble/getScrobbles.ts

··· 21 21 Effect.catchAll((err) => { 22 22 console.error("Error retrieving scrobbles:", err); 23 23 return Effect.succeed({ scrobbles: [] }); 24 24 - }) 24 24 + }), 25 25 ); 26 26 server.app.rocksky.scrobble.getScrobbles({ 27 27 handler: async ({ params }) => { ··· 58 58 }; 59 59 60 60 const presentation = ( 61 61 - data: Scrobbles 61 61 + data: Scrobbles, 62 62 ): Effect.Effect<{ scrobbles: ScrobbleViewBasic[] }, never> => { 63 63 return Effect.sync(() => ({ 64 64 scrobbles: data.map(({ scrobbles, tracks, users }) => ({

+8 -2

apps/api/src/xrpc/app/rocksky/song/createSong.ts

··· 19 19 import tables from "schema"; 20 20 import type { InsertAlbumTrack, SelectAlbumTrack } from "schema/album-tracks"; 21 21 import type { SelectAlbum } from "schema/albums"; 22 22 - import type { InsertArtistAlbum, SelectArtistAlbum } from "schema/artist-albums"; 23 23 - import type { InsertArtistTrack, SelectArtistTrack } from "schema/artist-tracks"; 22 22 + import type { 23 23 + InsertArtistAlbum, 24 24 + SelectArtistAlbum, 25 25 + } from "schema/artist-albums"; 26 26 + import type { 27 27 + InsertArtistTrack, 28 28 + SelectArtistTrack, 29 29 + } from "schema/artist-tracks"; 24 30 import type { SelectArtist } from "schema/artists"; 25 31 import type { SelectTrack } from "schema/tracks"; 26 32 import { type Track, trackSchema } from "types/track";

+14 -14

apps/api/src/xrpc/app/rocksky/spotify/getCurrentlyPlaying.ts

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.getCurrentlyPlaying({ 29 29 auth: ctx.authVerifier, ··· 54 54 .where( 55 55 or( 56 56 eq(tables.users.did, params.actor || did), 57 57 - eq(tables.users.handle, params.actor || did) 58 58 - ) 57 57 + eq(tables.users.handle, params.actor || did), 58 58 + ), 59 59 ) 60 60 .execute() 61 61 .then((users) => ({ user: users[0], ctx, params, did })), ··· 90 90 .from(tables.spotifyAccounts) 91 91 .leftJoin( 92 92 tables.users, 93 93 - eq(tables.users.id, tables.spotifyAccounts.userId) 93 93 + eq(tables.users.id, tables.spotifyAccounts.userId), 94 94 ) 95 95 .where( 96 96 or( 97 97 eq(tables.users.did, params.actor || did), 98 98 - eq(tables.users.handle, params.actor || did) 99 99 - ) 98 98 + eq(tables.users.handle, params.actor || did), 99 99 + ), 100 100 ) 101 101 .execute() 102 102 .then(([results]) => ({ ··· 129 129 Match.value(cached).pipe( 130 130 Match.when(null, () => ({})), 131 131 Match.when(undefined, () => ({})), 132 132 - Match.orElse(() => JSON.parse(cached)) 133 133 - ) 132 132 + Match.orElse(() => JSON.parse(cached)), 133 133 + ), 134 134 ) 135 135 .then((cached) => [cached, ctx, user]), 136 136 catch: (error) => ··· 143 143 try: async () => { 144 144 const sha256 = createHash("sha256") 145 145 .update( 146 146 - `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase() 146 146 + `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase(), 147 147 ) 148 148 .digest("hex"); 149 149 const [record] = await ctx.db ··· 156 156 .from(tables.lovedTracks) 157 157 .leftJoin( 158 158 tables.tracks, 159 159 - eq(tables.lovedTracks.trackId, tables.tracks.id) 159 159 + eq(tables.lovedTracks.trackId, tables.tracks.id), 160 160 ) 161 161 .leftJoin(tables.users, eq(tables.lovedTracks.userId, tables.users.id)) 162 162 .where( 163 163 - and(eq(tables.tracks.sha256, sha256), eq(tables.users.did, user.did)) 163 163 + and(eq(tables.tracks.sha256, sha256), eq(tables.users.did, user.did)), 164 164 ) 165 165 .execute() 166 166 .then((results) => 167 167 Match.value(track).pipe( 168 168 Match.when( 169 169 (t) => !Object.keys(t).length, 170 170 - () => ({}) 170 170 + () => ({}), 171 171 ), 172 172 Match.orElse(() => ({ 173 173 ...track, ··· 175 175 artistUri: record?.artistUri, 176 176 albumUri: record?.albumUri, 177 177 liked: results.length > 0, 178 178 - })) 179 179 - ) 178 178 + })), 179 179 + ), 180 180 ); 181 181 }, 182 182 catch: (error) => new Error(`Failed to retrieve URI and likes: ${error}`),

+2 -2

apps/api/src/xrpc/app/rocksky/spotify/next.ts

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.next({ 29 29 auth: ctx.authVerifier, ··· 72 72 .where(eq(tables.spotifyTokens.userId, user.id)) 73 73 .execute() 74 74 .then(([spotifyToken]) => 75 75 - decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY) 75 75 + decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY), 76 76 ) 77 77 .then((refreshToken) => ({ 78 78 user,

+2 -2

apps/api/src/xrpc/app/rocksky/spotify/pause.ts

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.pause({ 29 29 auth: ctx.authVerifier, ··· 72 72 .where(eq(tables.spotifyTokens.userId, user.id)) 73 73 .execute() 74 74 .then(([spotifyToken]) => 75 75 - decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY) 75 75 + decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY), 76 76 ) 77 77 .then((refreshToken) => ({ 78 78 user,

+2 -2

apps/api/src/xrpc/app/rocksky/spotify/play.ts

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.play({ 29 29 auth: ctx.authVerifier, ··· 72 72 .where(eq(tables.spotifyTokens.userId, user.id)) 73 73 .execute() 74 74 .then(([spotifyToken]) => 75 75 - decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY) 75 75 + decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY), 76 76 ) 77 77 .then((refreshToken) => ({ 78 78 user,

+2 -2

apps/api/src/xrpc/app/rocksky/spotify/previous.ts

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.previous({ 29 29 auth: ctx.authVerifier, ··· 72 72 .where(eq(tables.spotifyTokens.userId, user.id)) 73 73 .execute() 74 74 .then(([spotifyToken]) => 75 75 - decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY) 75 75 + decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY), 76 76 ) 77 77 .then((refreshToken) => ({ 78 78 refreshToken,