rocksky.app
tsiry-sandratraina.com
+17
apps/cli/drizzle.config.ts
+17
apps/cli/drizzle.config.ts
···
1
+
import { defineConfig } from "drizzle-kit";
2
+
import envpaths from "env-paths";
3
+
import fs from "node:fs";
4
+
import chalk from "chalk";
5
+
6
+
fs.mkdirSync(envpaths("rocksky", { suffix: "" }).data, { recursive: true });
7
+
const url = `${envpaths("rocksky", { suffix: "" }).data}/rocksky.sqlite`;
8
+
9
+
console.log(`Database URL: ${chalk.greenBright(url)}`);
10
+
11
+
export default defineConfig({
12
+
dialect: "sqlite",
13
+
schema: "./src/schema",
14
+
dbCredentials: {
15
+
url,
16
+
},
17
+
});
+159
apps/cli/drizzle/0000_amazing_redwing.sql
+159
apps/cli/drizzle/0000_amazing_redwing.sql
···
1
+
CREATE TABLE `album_tracks` (
2
+
`id` text PRIMARY KEY NOT NULL,
3
+
`album_id` text NOT NULL,
4
+
`track_id` text NOT NULL,
5
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
6
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
7
+
FOREIGN KEY (`album_id`) REFERENCES `albums`(`id`) ON UPDATE no action ON DELETE no action,
8
+
FOREIGN KEY (`track_id`) REFERENCES `tracks`(`id`) ON UPDATE no action ON DELETE no action
9
+
);
10
+
--> statement-breakpoint
11
+
CREATE TABLE `albums` (
12
+
`id` text PRIMARY KEY NOT NULL,
13
+
`title` text NOT NULL,
14
+
`artist` text NOT NULL,
15
+
`release_date` text,
16
+
`year` integer,
17
+
`album_art` text,
18
+
`uri` text,
19
+
`artist_uri` text,
20
+
`apple_music_link` text,
21
+
`spotify_link` text,
22
+
`tidal_link` text,
23
+
`youtube_link` text,
24
+
`sha256` text NOT NULL,
25
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
26
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL
27
+
);
28
+
--> statement-breakpoint
29
+
CREATE UNIQUE INDEX `albums_uri_unique` ON `albums` (`uri`);--> statement-breakpoint
30
+
CREATE UNIQUE INDEX `albums_apple_music_link_unique` ON `albums` (`apple_music_link`);--> statement-breakpoint
31
+
CREATE UNIQUE INDEX `albums_spotify_link_unique` ON `albums` (`spotify_link`);--> statement-breakpoint
32
+
CREATE UNIQUE INDEX `albums_tidal_link_unique` ON `albums` (`tidal_link`);--> statement-breakpoint
33
+
CREATE UNIQUE INDEX `albums_youtube_link_unique` ON `albums` (`youtube_link`);--> statement-breakpoint
34
+
CREATE UNIQUE INDEX `albums_sha256_unique` ON `albums` (`sha256`);--> statement-breakpoint
35
+
CREATE TABLE `artist_albums` (
36
+
`id` text PRIMARY KEY NOT NULL,
37
+
`artist_id` text NOT NULL,
38
+
`album_id` text NOT NULL,
39
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
40
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
41
+
FOREIGN KEY (`artist_id`) REFERENCES `artists`(`id`) ON UPDATE no action ON DELETE no action,
42
+
FOREIGN KEY (`album_id`) REFERENCES `albums`(`id`) ON UPDATE no action ON DELETE no action
43
+
);
44
+
--> statement-breakpoint
45
+
CREATE TABLE `artist_tracks` (
46
+
`id` text PRIMARY KEY NOT NULL,
47
+
`artist_id` text NOT NULL,
48
+
`track_id` text NOT NULL,
49
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
50
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
51
+
FOREIGN KEY (`artist_id`) REFERENCES `artists`(`id`) ON UPDATE no action ON DELETE no action,
52
+
FOREIGN KEY (`track_id`) REFERENCES `tracks`(`id`) ON UPDATE no action ON DELETE no action
53
+
);
54
+
--> statement-breakpoint
55
+
CREATE TABLE `artists` (
56
+
`id` text PRIMARY KEY NOT NULL,
57
+
`name` text NOT NULL,
58
+
`biography` text,
59
+
`born` integer,
60
+
`born_in` text,
61
+
`died` integer,
62
+
`picture` text,
63
+
`sha256` text NOT NULL,
64
+
`uri` text,
65
+
`apple_music_link` text,
66
+
`spotify_link` text,
67
+
`tidal_link` text,
68
+
`youtube_link` text,
69
+
`genres` text,
70
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
71
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL
72
+
);
73
+
--> statement-breakpoint
74
+
CREATE UNIQUE INDEX `artists_sha256_unique` ON `artists` (`sha256`);--> statement-breakpoint
75
+
CREATE UNIQUE INDEX `artists_uri_unique` ON `artists` (`uri`);--> statement-breakpoint
76
+
CREATE TABLE `loved_tracks` (
77
+
`id` text PRIMARY KEY NOT NULL,
78
+
`user_id` text NOT NULL,
79
+
`track_id` text NOT NULL,
80
+
`uri` text,
81
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
82
+
FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action,
83
+
FOREIGN KEY (`track_id`) REFERENCES `tracks`(`id`) ON UPDATE no action ON DELETE no action
84
+
);
85
+
--> statement-breakpoint
86
+
CREATE UNIQUE INDEX `loved_tracks_uri_unique` ON `loved_tracks` (`uri`);--> statement-breakpoint
87
+
CREATE TABLE `tracks` (
88
+
`id` text PRIMARY KEY NOT NULL,
89
+
`title` text NOT NULL,
90
+
`artist` text NOT NULL,
91
+
`album_artist` text NOT NULL,
92
+
`album_art` text,
93
+
`album` text NOT NULL,
94
+
`track_number` integer,
95
+
`duration` integer NOT NULL,
96
+
`mb_id` text,
97
+
`youtube_link` text,
98
+
`spotify_link` text,
99
+
`apple_music_link` text,
100
+
`tidal_link` text,
101
+
`sha256` text NOT NULL,
102
+
`disc_number` integer,
103
+
`lyrics` text,
104
+
`composer` text,
105
+
`genre` text,
106
+
`label` text,
107
+
`copyright_message` text,
108
+
`uri` text,
109
+
`album_uri` text,
110
+
`artist_uri` text,
111
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
112
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL
113
+
);
114
+
--> statement-breakpoint
115
+
CREATE UNIQUE INDEX `tracks_mb_id_unique` ON `tracks` (`mb_id`);--> statement-breakpoint
116
+
CREATE UNIQUE INDEX `tracks_youtube_link_unique` ON `tracks` (`youtube_link`);--> statement-breakpoint
117
+
CREATE UNIQUE INDEX `tracks_spotify_link_unique` ON `tracks` (`spotify_link`);--> statement-breakpoint
118
+
CREATE UNIQUE INDEX `tracks_apple_music_link_unique` ON `tracks` (`apple_music_link`);--> statement-breakpoint
119
+
CREATE UNIQUE INDEX `tracks_tidal_link_unique` ON `tracks` (`tidal_link`);--> statement-breakpoint
120
+
CREATE UNIQUE INDEX `tracks_sha256_unique` ON `tracks` (`sha256`);--> statement-breakpoint
121
+
CREATE UNIQUE INDEX `tracks_uri_unique` ON `tracks` (`uri`);--> statement-breakpoint
122
+
CREATE TABLE `user_albums` (
123
+
`id` text PRIMARY KEY NOT NULL,
124
+
`user_id` text NOT NULL,
125
+
`artist_id` text NOT NULL,
126
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
127
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
128
+
`scrobbles` integer,
129
+
`uri` text NOT NULL,
130
+
FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action,
131
+
FOREIGN KEY (`artist_id`) REFERENCES `artists`(`id`) ON UPDATE no action ON DELETE no action
132
+
);
133
+
--> statement-breakpoint
134
+
CREATE UNIQUE INDEX `user_albums_uri_unique` ON `user_albums` (`uri`);--> statement-breakpoint
135
+
CREATE TABLE `user_tracks` (
136
+
`id` text PRIMARY KEY NOT NULL,
137
+
`user_id` text NOT NULL,
138
+
`track_id` text NOT NULL,
139
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
140
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
141
+
`scrobbles` integer,
142
+
`uri` text NOT NULL,
143
+
FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action,
144
+
FOREIGN KEY (`track_id`) REFERENCES `tracks`(`id`) ON UPDATE no action ON DELETE no action
145
+
);
146
+
--> statement-breakpoint
147
+
CREATE UNIQUE INDEX `user_tracks_uri_unique` ON `user_tracks` (`uri`);--> statement-breakpoint
148
+
CREATE TABLE `users` (
149
+
`id` text PRIMARY KEY NOT NULL,
150
+
`did` text NOT NULL,
151
+
`display_name` text,
152
+
`handle` text NOT NULL,
153
+
`avatar` text NOT NULL,
154
+
`created_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL,
155
+
`updated_at` integer DEFAULT CURRENT_TIMESTAMP NOT NULL
156
+
);
157
+
--> statement-breakpoint
158
+
CREATE UNIQUE INDEX `users_did_unique` ON `users` (`did`);--> statement-breakpoint
159
+
CREATE UNIQUE INDEX `users_handle_unique` ON `users` (`handle`);
+1125
apps/cli/drizzle/meta/0000_snapshot.json
+1125
apps/cli/drizzle/meta/0000_snapshot.json
···
1
+
{
2
+
"version": "6",
3
+
"dialect": "sqlite",
4
+
"id": "a549f070-9d4d-4d38-bd6a-c04bc9a4889b",
5
+
"prevId": "00000000-0000-0000-0000-000000000000",
6
+
"tables": {
7
+
"album_tracks": {
8
+
"name": "album_tracks",
9
+
"columns": {
10
+
"id": {
11
+
"name": "id",
12
+
"type": "text",
13
+
"primaryKey": true,
14
+
"notNull": true,
15
+
"autoincrement": false
16
+
},
17
+
"album_id": {
18
+
"name": "album_id",
19
+
"type": "text",
20
+
"primaryKey": false,
21
+
"notNull": true,
22
+
"autoincrement": false
23
+
},
24
+
"track_id": {
25
+
"name": "track_id",
26
+
"type": "text",
27
+
"primaryKey": false,
28
+
"notNull": true,
29
+
"autoincrement": false
30
+
},
31
+
"created_at": {
32
+
"name": "created_at",
33
+
"type": "integer",
34
+
"primaryKey": false,
35
+
"notNull": true,
36
+
"autoincrement": false,
37
+
"default": "CURRENT_TIMESTAMP"
38
+
},
39
+
"updated_at": {
40
+
"name": "updated_at",
41
+
"type": "integer",
42
+
"primaryKey": false,
43
+
"notNull": true,
44
+
"autoincrement": false,
45
+
"default": "CURRENT_TIMESTAMP"
46
+
}
47
+
},
48
+
"indexes": {},
49
+
"foreignKeys": {
50
+
"album_tracks_album_id_albums_id_fk": {
51
+
"name": "album_tracks_album_id_albums_id_fk",
52
+
"tableFrom": "album_tracks",
53
+
"tableTo": "albums",
54
+
"columnsFrom": [
55
+
"album_id"
56
+
],
57
+
"columnsTo": [
58
+
"id"
59
+
],
60
+
"onDelete": "no action",
61
+
"onUpdate": "no action"
62
+
},
63
+
"album_tracks_track_id_tracks_id_fk": {
64
+
"name": "album_tracks_track_id_tracks_id_fk",
65
+
"tableFrom": "album_tracks",
66
+
"tableTo": "tracks",
67
+
"columnsFrom": [
68
+
"track_id"
69
+
],
70
+
"columnsTo": [
71
+
"id"
72
+
],
73
+
"onDelete": "no action",
74
+
"onUpdate": "no action"
75
+
}
76
+
},
77
+
"compositePrimaryKeys": {},
78
+
"uniqueConstraints": {},
79
+
"checkConstraints": {}
80
+
},
81
+
"albums": {
82
+
"name": "albums",
83
+
"columns": {
84
+
"id": {
85
+
"name": "id",
86
+
"type": "text",
87
+
"primaryKey": true,
88
+
"notNull": true,
89
+
"autoincrement": false
90
+
},
91
+
"title": {
92
+
"name": "title",
93
+
"type": "text",
94
+
"primaryKey": false,
95
+
"notNull": true,
96
+
"autoincrement": false
97
+
},
98
+
"artist": {
99
+
"name": "artist",
100
+
"type": "text",
101
+
"primaryKey": false,
102
+
"notNull": true,
103
+
"autoincrement": false
104
+
},
105
+
"release_date": {
106
+
"name": "release_date",
107
+
"type": "text",
108
+
"primaryKey": false,
109
+
"notNull": false,
110
+
"autoincrement": false
111
+
},
112
+
"year": {
113
+
"name": "year",
114
+
"type": "integer",
115
+
"primaryKey": false,
116
+
"notNull": false,
117
+
"autoincrement": false
118
+
},
119
+
"album_art": {
120
+
"name": "album_art",
121
+
"type": "text",
122
+
"primaryKey": false,
123
+
"notNull": false,
124
+
"autoincrement": false
125
+
},
126
+
"uri": {
127
+
"name": "uri",
128
+
"type": "text",
129
+
"primaryKey": false,
130
+
"notNull": false,
131
+
"autoincrement": false
132
+
},
133
+
"artist_uri": {
134
+
"name": "artist_uri",
135
+
"type": "text",
136
+
"primaryKey": false,
137
+
"notNull": false,
138
+
"autoincrement": false
139
+
},
140
+
"apple_music_link": {
141
+
"name": "apple_music_link",
142
+
"type": "text",
143
+
"primaryKey": false,
144
+
"notNull": false,
145
+
"autoincrement": false
146
+
},
147
+
"spotify_link": {
148
+
"name": "spotify_link",
149
+
"type": "text",
150
+
"primaryKey": false,
151
+
"notNull": false,
152
+
"autoincrement": false
153
+
},
154
+
"tidal_link": {
155
+
"name": "tidal_link",
156
+
"type": "text",
157
+
"primaryKey": false,
158
+
"notNull": false,
159
+
"autoincrement": false
160
+
},
161
+
"youtube_link": {
162
+
"name": "youtube_link",
163
+
"type": "text",
164
+
"primaryKey": false,
165
+
"notNull": false,
166
+
"autoincrement": false
167
+
},
168
+
"sha256": {
169
+
"name": "sha256",
170
+
"type": "text",
171
+
"primaryKey": false,
172
+
"notNull": true,
173
+
"autoincrement": false
174
+
},
175
+
"created_at": {
176
+
"name": "created_at",
177
+
"type": "integer",
178
+
"primaryKey": false,
179
+
"notNull": true,
180
+
"autoincrement": false,
181
+
"default": "CURRENT_TIMESTAMP"
182
+
},
183
+
"updated_at": {
184
+
"name": "updated_at",
185
+
"type": "integer",
186
+
"primaryKey": false,
187
+
"notNull": true,
188
+
"autoincrement": false,
189
+
"default": "CURRENT_TIMESTAMP"
190
+
}
191
+
},
192
+
"indexes": {
193
+
"albums_uri_unique": {
194
+
"name": "albums_uri_unique",
195
+
"columns": [
196
+
"uri"
197
+
],
198
+
"isUnique": true
199
+
},
200
+
"albums_apple_music_link_unique": {
201
+
"name": "albums_apple_music_link_unique",
202
+
"columns": [
203
+
"apple_music_link"
204
+
],
205
+
"isUnique": true
206
+
},
207
+
"albums_spotify_link_unique": {
208
+
"name": "albums_spotify_link_unique",
209
+
"columns": [
210
+
"spotify_link"
211
+
],
212
+
"isUnique": true
213
+
},
214
+
"albums_tidal_link_unique": {
215
+
"name": "albums_tidal_link_unique",
216
+
"columns": [
217
+
"tidal_link"
218
+
],
219
+
"isUnique": true
220
+
},
221
+
"albums_youtube_link_unique": {
222
+
"name": "albums_youtube_link_unique",
223
+
"columns": [
224
+
"youtube_link"
225
+
],
226
+
"isUnique": true
227
+
},
228
+
"albums_sha256_unique": {
229
+
"name": "albums_sha256_unique",
230
+
"columns": [
231
+
"sha256"
232
+
],
233
+
"isUnique": true
234
+
}
235
+
},
236
+
"foreignKeys": {},
237
+
"compositePrimaryKeys": {},
238
+
"uniqueConstraints": {},
239
+
"checkConstraints": {}
240
+
},
241
+
"artist_albums": {
242
+
"name": "artist_albums",
243
+
"columns": {
244
+
"id": {
245
+
"name": "id",
246
+
"type": "text",
247
+
"primaryKey": true,
248
+
"notNull": true,
249
+
"autoincrement": false
250
+
},
251
+
"artist_id": {
252
+
"name": "artist_id",
253
+
"type": "text",
254
+
"primaryKey": false,
255
+
"notNull": true,
256
+
"autoincrement": false
257
+
},
258
+
"album_id": {
259
+
"name": "album_id",
260
+
"type": "text",
261
+
"primaryKey": false,
262
+
"notNull": true,
263
+
"autoincrement": false
264
+
},
265
+
"created_at": {
266
+
"name": "created_at",
267
+
"type": "integer",
268
+
"primaryKey": false,
269
+
"notNull": true,
270
+
"autoincrement": false,
271
+
"default": "CURRENT_TIMESTAMP"
272
+
},
273
+
"updated_at": {
274
+
"name": "updated_at",
275
+
"type": "integer",
276
+
"primaryKey": false,
277
+
"notNull": true,
278
+
"autoincrement": false,
279
+
"default": "CURRENT_TIMESTAMP"
280
+
}
281
+
},
282
+
"indexes": {},
283
+
"foreignKeys": {
284
+
"artist_albums_artist_id_artists_id_fk": {
285
+
"name": "artist_albums_artist_id_artists_id_fk",
286
+
"tableFrom": "artist_albums",
287
+
"tableTo": "artists",
288
+
"columnsFrom": [
289
+
"artist_id"
290
+
],
291
+
"columnsTo": [
292
+
"id"
293
+
],
294
+
"onDelete": "no action",
295
+
"onUpdate": "no action"
296
+
},
297
+
"artist_albums_album_id_albums_id_fk": {
298
+
"name": "artist_albums_album_id_albums_id_fk",
299
+
"tableFrom": "artist_albums",
300
+
"tableTo": "albums",
301
+
"columnsFrom": [
302
+
"album_id"
303
+
],
304
+
"columnsTo": [
305
+
"id"
306
+
],
307
+
"onDelete": "no action",
308
+
"onUpdate": "no action"
309
+
}
310
+
},
311
+
"compositePrimaryKeys": {},
312
+
"uniqueConstraints": {},
313
+
"checkConstraints": {}
314
+
},
315
+
"artist_tracks": {
316
+
"name": "artist_tracks",
317
+
"columns": {
318
+
"id": {
319
+
"name": "id",
320
+
"type": "text",
321
+
"primaryKey": true,
322
+
"notNull": true,
323
+
"autoincrement": false
324
+
},
325
+
"artist_id": {
326
+
"name": "artist_id",
327
+
"type": "text",
328
+
"primaryKey": false,
329
+
"notNull": true,
330
+
"autoincrement": false
331
+
},
332
+
"track_id": {
333
+
"name": "track_id",
334
+
"type": "text",
335
+
"primaryKey": false,
336
+
"notNull": true,
337
+
"autoincrement": false
338
+
},
339
+
"created_at": {
340
+
"name": "created_at",
341
+
"type": "integer",
342
+
"primaryKey": false,
343
+
"notNull": true,
344
+
"autoincrement": false,
345
+
"default": "CURRENT_TIMESTAMP"
346
+
},
347
+
"updated_at": {
348
+
"name": "updated_at",
349
+
"type": "integer",
350
+
"primaryKey": false,
351
+
"notNull": true,
352
+
"autoincrement": false,
353
+
"default": "CURRENT_TIMESTAMP"
354
+
}
355
+
},
356
+
"indexes": {},
357
+
"foreignKeys": {
358
+
"artist_tracks_artist_id_artists_id_fk": {
359
+
"name": "artist_tracks_artist_id_artists_id_fk",
360
+
"tableFrom": "artist_tracks",
361
+
"tableTo": "artists",
362
+
"columnsFrom": [
363
+
"artist_id"
364
+
],
365
+
"columnsTo": [
366
+
"id"
367
+
],
368
+
"onDelete": "no action",
369
+
"onUpdate": "no action"
370
+
},
371
+
"artist_tracks_track_id_tracks_id_fk": {
372
+
"name": "artist_tracks_track_id_tracks_id_fk",
373
+
"tableFrom": "artist_tracks",
374
+
"tableTo": "tracks",
375
+
"columnsFrom": [
376
+
"track_id"
377
+
],
378
+
"columnsTo": [
379
+
"id"
380
+
],
381
+
"onDelete": "no action",
382
+
"onUpdate": "no action"
383
+
}
384
+
},
385
+
"compositePrimaryKeys": {},
386
+
"uniqueConstraints": {},
387
+
"checkConstraints": {}
388
+
},
389
+
"artists": {
390
+
"name": "artists",
391
+
"columns": {
392
+
"id": {
393
+
"name": "id",
394
+
"type": "text",
395
+
"primaryKey": true,
396
+
"notNull": true,
397
+
"autoincrement": false
398
+
},
399
+
"name": {
400
+
"name": "name",
401
+
"type": "text",
402
+
"primaryKey": false,
403
+
"notNull": true,
404
+
"autoincrement": false
405
+
},
406
+
"biography": {
407
+
"name": "biography",
408
+
"type": "text",
409
+
"primaryKey": false,
410
+
"notNull": false,
411
+
"autoincrement": false
412
+
},
413
+
"born": {
414
+
"name": "born",
415
+
"type": "integer",
416
+
"primaryKey": false,
417
+
"notNull": false,
418
+
"autoincrement": false
419
+
},
420
+
"born_in": {
421
+
"name": "born_in",
422
+
"type": "text",
423
+
"primaryKey": false,
424
+
"notNull": false,
425
+
"autoincrement": false
426
+
},
427
+
"died": {
428
+
"name": "died",
429
+
"type": "integer",
430
+
"primaryKey": false,
431
+
"notNull": false,
432
+
"autoincrement": false
433
+
},
434
+
"picture": {
435
+
"name": "picture",
436
+
"type": "text",
437
+
"primaryKey": false,
438
+
"notNull": false,
439
+
"autoincrement": false
440
+
},
441
+
"sha256": {
442
+
"name": "sha256",
443
+
"type": "text",
444
+
"primaryKey": false,
445
+
"notNull": true,
446
+
"autoincrement": false
447
+
},
448
+
"uri": {
449
+
"name": "uri",
450
+
"type": "text",
451
+
"primaryKey": false,
452
+
"notNull": false,
453
+
"autoincrement": false
454
+
},
455
+
"apple_music_link": {
456
+
"name": "apple_music_link",
457
+
"type": "text",
458
+
"primaryKey": false,
459
+
"notNull": false,
460
+
"autoincrement": false
461
+
},
462
+
"spotify_link": {
463
+
"name": "spotify_link",
464
+
"type": "text",
465
+
"primaryKey": false,
466
+
"notNull": false,
467
+
"autoincrement": false
468
+
},
469
+
"tidal_link": {
470
+
"name": "tidal_link",
471
+
"type": "text",
472
+
"primaryKey": false,
473
+
"notNull": false,
474
+
"autoincrement": false
475
+
},
476
+
"youtube_link": {
477
+
"name": "youtube_link",
478
+
"type": "text",
479
+
"primaryKey": false,
480
+
"notNull": false,
481
+
"autoincrement": false
482
+
},
483
+
"genres": {
484
+
"name": "genres",
485
+
"type": "text",
486
+
"primaryKey": false,
487
+
"notNull": false,
488
+
"autoincrement": false
489
+
},
490
+
"created_at": {
491
+
"name": "created_at",
492
+
"type": "integer",
493
+
"primaryKey": false,
494
+
"notNull": true,
495
+
"autoincrement": false,
496
+
"default": "CURRENT_TIMESTAMP"
497
+
},
498
+
"updated_at": {
499
+
"name": "updated_at",
500
+
"type": "integer",
501
+
"primaryKey": false,
502
+
"notNull": true,
503
+
"autoincrement": false,
504
+
"default": "CURRENT_TIMESTAMP"
505
+
}
506
+
},
507
+
"indexes": {
508
+
"artists_sha256_unique": {
509
+
"name": "artists_sha256_unique",
510
+
"columns": [
511
+
"sha256"
512
+
],
513
+
"isUnique": true
514
+
},
515
+
"artists_uri_unique": {
516
+
"name": "artists_uri_unique",
517
+
"columns": [
518
+
"uri"
519
+
],
520
+
"isUnique": true
521
+
}
522
+
},
523
+
"foreignKeys": {},
524
+
"compositePrimaryKeys": {},
525
+
"uniqueConstraints": {},
526
+
"checkConstraints": {}
527
+
},
528
+
"loved_tracks": {
529
+
"name": "loved_tracks",
530
+
"columns": {
531
+
"id": {
532
+
"name": "id",
533
+
"type": "text",
534
+
"primaryKey": true,
535
+
"notNull": true,
536
+
"autoincrement": false
537
+
},
538
+
"user_id": {
539
+
"name": "user_id",
540
+
"type": "text",
541
+
"primaryKey": false,
542
+
"notNull": true,
543
+
"autoincrement": false
544
+
},
545
+
"track_id": {
546
+
"name": "track_id",
547
+
"type": "text",
548
+
"primaryKey": false,
549
+
"notNull": true,
550
+
"autoincrement": false
551
+
},
552
+
"uri": {
553
+
"name": "uri",
554
+
"type": "text",
555
+
"primaryKey": false,
556
+
"notNull": false,
557
+
"autoincrement": false
558
+
},
559
+
"created_at": {
560
+
"name": "created_at",
561
+
"type": "integer",
562
+
"primaryKey": false,
563
+
"notNull": true,
564
+
"autoincrement": false,
565
+
"default": "CURRENT_TIMESTAMP"
566
+
}
567
+
},
568
+
"indexes": {
569
+
"loved_tracks_uri_unique": {
570
+
"name": "loved_tracks_uri_unique",
571
+
"columns": [
572
+
"uri"
573
+
],
574
+
"isUnique": true
575
+
}
576
+
},
577
+
"foreignKeys": {
578
+
"loved_tracks_user_id_users_id_fk": {
579
+
"name": "loved_tracks_user_id_users_id_fk",
580
+
"tableFrom": "loved_tracks",
581
+
"tableTo": "users",
582
+
"columnsFrom": [
583
+
"user_id"
584
+
],
585
+
"columnsTo": [
586
+
"id"
587
+
],
588
+
"onDelete": "no action",
589
+
"onUpdate": "no action"
590
+
},
591
+
"loved_tracks_track_id_tracks_id_fk": {
592
+
"name": "loved_tracks_track_id_tracks_id_fk",
593
+
"tableFrom": "loved_tracks",
594
+
"tableTo": "tracks",
595
+
"columnsFrom": [
596
+
"track_id"
597
+
],
598
+
"columnsTo": [
599
+
"id"
600
+
],
601
+
"onDelete": "no action",
602
+
"onUpdate": "no action"
603
+
}
604
+
},
605
+
"compositePrimaryKeys": {},
606
+
"uniqueConstraints": {},
607
+
"checkConstraints": {}
608
+
},
609
+
"tracks": {
610
+
"name": "tracks",
611
+
"columns": {
612
+
"id": {
613
+
"name": "id",
614
+
"type": "text",
615
+
"primaryKey": true,
616
+
"notNull": true,
617
+
"autoincrement": false
618
+
},
619
+
"title": {
620
+
"name": "title",
621
+
"type": "text",
622
+
"primaryKey": false,
623
+
"notNull": true,
624
+
"autoincrement": false
625
+
},
626
+
"artist": {
627
+
"name": "artist",
628
+
"type": "text",
629
+
"primaryKey": false,
630
+
"notNull": true,
631
+
"autoincrement": false
632
+
},
633
+
"album_artist": {
634
+
"name": "album_artist",
635
+
"type": "text",
636
+
"primaryKey": false,
637
+
"notNull": true,
638
+
"autoincrement": false
639
+
},
640
+
"album_art": {
641
+
"name": "album_art",
642
+
"type": "text",
643
+
"primaryKey": false,
644
+
"notNull": false,
645
+
"autoincrement": false
646
+
},
647
+
"album": {
648
+
"name": "album",
649
+
"type": "text",
650
+
"primaryKey": false,
651
+
"notNull": true,
652
+
"autoincrement": false
653
+
},
654
+
"track_number": {
655
+
"name": "track_number",
656
+
"type": "integer",
657
+
"primaryKey": false,
658
+
"notNull": false,
659
+
"autoincrement": false
660
+
},
661
+
"duration": {
662
+
"name": "duration",
663
+
"type": "integer",
664
+
"primaryKey": false,
665
+
"notNull": true,
666
+
"autoincrement": false
667
+
},
668
+
"mb_id": {
669
+
"name": "mb_id",
670
+
"type": "text",
671
+
"primaryKey": false,
672
+
"notNull": false,
673
+
"autoincrement": false
674
+
},
675
+
"youtube_link": {
676
+
"name": "youtube_link",
677
+
"type": "text",
678
+
"primaryKey": false,
679
+
"notNull": false,
680
+
"autoincrement": false
681
+
},
682
+
"spotify_link": {
683
+
"name": "spotify_link",
684
+
"type": "text",
685
+
"primaryKey": false,
686
+
"notNull": false,
687
+
"autoincrement": false
688
+
},
689
+
"apple_music_link": {
690
+
"name": "apple_music_link",
691
+
"type": "text",
692
+
"primaryKey": false,
693
+
"notNull": false,
694
+
"autoincrement": false
695
+
},
696
+
"tidal_link": {
697
+
"name": "tidal_link",
698
+
"type": "text",
699
+
"primaryKey": false,
700
+
"notNull": false,
701
+
"autoincrement": false
702
+
},
703
+
"sha256": {
704
+
"name": "sha256",
705
+
"type": "text",
706
+
"primaryKey": false,
707
+
"notNull": true,
708
+
"autoincrement": false
709
+
},
710
+
"disc_number": {
711
+
"name": "disc_number",
712
+
"type": "integer",
713
+
"primaryKey": false,
714
+
"notNull": false,
715
+
"autoincrement": false
716
+
},
717
+
"lyrics": {
718
+
"name": "lyrics",
719
+
"type": "text",
720
+
"primaryKey": false,
721
+
"notNull": false,
722
+
"autoincrement": false
723
+
},
724
+
"composer": {
725
+
"name": "composer",
726
+
"type": "text",
727
+
"primaryKey": false,
728
+
"notNull": false,
729
+
"autoincrement": false
730
+
},
731
+
"genre": {
732
+
"name": "genre",
733
+
"type": "text",
734
+
"primaryKey": false,
735
+
"notNull": false,
736
+
"autoincrement": false
737
+
},
738
+
"label": {
739
+
"name": "label",
740
+
"type": "text",
741
+
"primaryKey": false,
742
+
"notNull": false,
743
+
"autoincrement": false
744
+
},
745
+
"copyright_message": {
746
+
"name": "copyright_message",
747
+
"type": "text",
748
+
"primaryKey": false,
749
+
"notNull": false,
750
+
"autoincrement": false
751
+
},
752
+
"uri": {
753
+
"name": "uri",
754
+
"type": "text",
755
+
"primaryKey": false,
756
+
"notNull": false,
757
+
"autoincrement": false
758
+
},
759
+
"album_uri": {
760
+
"name": "album_uri",
761
+
"type": "text",
762
+
"primaryKey": false,
763
+
"notNull": false,
764
+
"autoincrement": false
765
+
},
766
+
"artist_uri": {
767
+
"name": "artist_uri",
768
+
"type": "text",
769
+
"primaryKey": false,
770
+
"notNull": false,
771
+
"autoincrement": false
772
+
},
773
+
"created_at": {
774
+
"name": "created_at",
775
+
"type": "integer",
776
+
"primaryKey": false,
777
+
"notNull": true,
778
+
"autoincrement": false,
779
+
"default": "CURRENT_TIMESTAMP"
780
+
},
781
+
"updated_at": {
782
+
"name": "updated_at",
783
+
"type": "integer",
784
+
"primaryKey": false,
785
+
"notNull": true,
786
+
"autoincrement": false,
787
+
"default": "CURRENT_TIMESTAMP"
788
+
}
789
+
},
790
+
"indexes": {
791
+
"tracks_mb_id_unique": {
792
+
"name": "tracks_mb_id_unique",
793
+
"columns": [
794
+
"mb_id"
795
+
],
796
+
"isUnique": true
797
+
},
798
+
"tracks_youtube_link_unique": {
799
+
"name": "tracks_youtube_link_unique",
800
+
"columns": [
801
+
"youtube_link"
802
+
],
803
+
"isUnique": true
804
+
},
805
+
"tracks_spotify_link_unique": {
806
+
"name": "tracks_spotify_link_unique",
807
+
"columns": [
808
+
"spotify_link"
809
+
],
810
+
"isUnique": true
811
+
},
812
+
"tracks_apple_music_link_unique": {
813
+
"name": "tracks_apple_music_link_unique",
814
+
"columns": [
815
+
"apple_music_link"
816
+
],
817
+
"isUnique": true
818
+
},
819
+
"tracks_tidal_link_unique": {
820
+
"name": "tracks_tidal_link_unique",
821
+
"columns": [
822
+
"tidal_link"
823
+
],
824
+
"isUnique": true
825
+
},
826
+
"tracks_sha256_unique": {
827
+
"name": "tracks_sha256_unique",
828
+
"columns": [
829
+
"sha256"
830
+
],
831
+
"isUnique": true
832
+
},
833
+
"tracks_uri_unique": {
834
+
"name": "tracks_uri_unique",
835
+
"columns": [
836
+
"uri"
837
+
],
838
+
"isUnique": true
839
+
}
840
+
},
841
+
"foreignKeys": {},
842
+
"compositePrimaryKeys": {},
843
+
"uniqueConstraints": {},
844
+
"checkConstraints": {}
845
+
},
846
+
"user_albums": {
847
+
"name": "user_albums",
848
+
"columns": {
849
+
"id": {
850
+
"name": "id",
851
+
"type": "text",
852
+
"primaryKey": true,
853
+
"notNull": true,
854
+
"autoincrement": false
855
+
},
856
+
"user_id": {
857
+
"name": "user_id",
858
+
"type": "text",
859
+
"primaryKey": false,
860
+
"notNull": true,
861
+
"autoincrement": false
862
+
},
863
+
"artist_id": {
864
+
"name": "artist_id",
865
+
"type": "text",
866
+
"primaryKey": false,
867
+
"notNull": true,
868
+
"autoincrement": false
869
+
},
870
+
"created_at": {
871
+
"name": "created_at",
872
+
"type": "integer",
873
+
"primaryKey": false,
874
+
"notNull": true,
875
+
"autoincrement": false,
876
+
"default": "CURRENT_TIMESTAMP"
877
+
},
878
+
"updated_at": {
879
+
"name": "updated_at",
880
+
"type": "integer",
881
+
"primaryKey": false,
882
+
"notNull": true,
883
+
"autoincrement": false,
884
+
"default": "CURRENT_TIMESTAMP"
885
+
},
886
+
"scrobbles": {
887
+
"name": "scrobbles",
888
+
"type": "integer",
889
+
"primaryKey": false,
890
+
"notNull": false,
891
+
"autoincrement": false
892
+
},
893
+
"uri": {
894
+
"name": "uri",
895
+
"type": "text",
896
+
"primaryKey": false,
897
+
"notNull": true,
898
+
"autoincrement": false
899
+
}
900
+
},
901
+
"indexes": {
902
+
"user_albums_uri_unique": {
903
+
"name": "user_albums_uri_unique",
904
+
"columns": [
905
+
"uri"
906
+
],
907
+
"isUnique": true
908
+
}
909
+
},
910
+
"foreignKeys": {
911
+
"user_albums_user_id_users_id_fk": {
912
+
"name": "user_albums_user_id_users_id_fk",
913
+
"tableFrom": "user_albums",
914
+
"tableTo": "users",
915
+
"columnsFrom": [
916
+
"user_id"
917
+
],
918
+
"columnsTo": [
919
+
"id"
920
+
],
921
+
"onDelete": "no action",
922
+
"onUpdate": "no action"
923
+
},
924
+
"user_albums_artist_id_artists_id_fk": {
925
+
"name": "user_albums_artist_id_artists_id_fk",
926
+
"tableFrom": "user_albums",
927
+
"tableTo": "artists",
928
+
"columnsFrom": [
929
+
"artist_id"
930
+
],
931
+
"columnsTo": [
932
+
"id"
933
+
],
934
+
"onDelete": "no action",
935
+
"onUpdate": "no action"
936
+
}
937
+
},
938
+
"compositePrimaryKeys": {},
939
+
"uniqueConstraints": {},
940
+
"checkConstraints": {}
941
+
},
942
+
"user_tracks": {
943
+
"name": "user_tracks",
944
+
"columns": {
945
+
"id": {
946
+
"name": "id",
947
+
"type": "text",
948
+
"primaryKey": true,
949
+
"notNull": true,
950
+
"autoincrement": false
951
+
},
952
+
"user_id": {
953
+
"name": "user_id",
954
+
"type": "text",
955
+
"primaryKey": false,
956
+
"notNull": true,
957
+
"autoincrement": false
958
+
},
959
+
"track_id": {
960
+
"name": "track_id",
961
+
"type": "text",
962
+
"primaryKey": false,
963
+
"notNull": true,
964
+
"autoincrement": false
965
+
},
966
+
"created_at": {
967
+
"name": "created_at",
968
+
"type": "integer",
969
+
"primaryKey": false,
970
+
"notNull": true,
971
+
"autoincrement": false,
972
+
"default": "CURRENT_TIMESTAMP"
973
+
},
974
+
"updated_at": {
975
+
"name": "updated_at",
976
+
"type": "integer",
977
+
"primaryKey": false,
978
+
"notNull": true,
979
+
"autoincrement": false,
980
+
"default": "CURRENT_TIMESTAMP"
981
+
},
982
+
"scrobbles": {
983
+
"name": "scrobbles",
984
+
"type": "integer",
985
+
"primaryKey": false,
986
+
"notNull": false,
987
+
"autoincrement": false
988
+
},
989
+
"uri": {
990
+
"name": "uri",
991
+
"type": "text",
992
+
"primaryKey": false,
993
+
"notNull": true,
994
+
"autoincrement": false
995
+
}
996
+
},
997
+
"indexes": {
998
+
"user_tracks_uri_unique": {
999
+
"name": "user_tracks_uri_unique",
1000
+
"columns": [
1001
+
"uri"
1002
+
],
1003
+
"isUnique": true
1004
+
}
1005
+
},
1006
+
"foreignKeys": {
1007
+
"user_tracks_user_id_users_id_fk": {
1008
+
"name": "user_tracks_user_id_users_id_fk",
1009
+
"tableFrom": "user_tracks",
1010
+
"tableTo": "users",
1011
+
"columnsFrom": [
1012
+
"user_id"
1013
+
],
1014
+
"columnsTo": [
1015
+
"id"
1016
+
],
1017
+
"onDelete": "no action",
1018
+
"onUpdate": "no action"
1019
+
},
1020
+
"user_tracks_track_id_tracks_id_fk": {
1021
+
"name": "user_tracks_track_id_tracks_id_fk",
1022
+
"tableFrom": "user_tracks",
1023
+
"tableTo": "tracks",
1024
+
"columnsFrom": [
1025
+
"track_id"
1026
+
],
1027
+
"columnsTo": [
1028
+
"id"
1029
+
],
1030
+
"onDelete": "no action",
1031
+
"onUpdate": "no action"
1032
+
}
1033
+
},
1034
+
"compositePrimaryKeys": {},
1035
+
"uniqueConstraints": {},
1036
+
"checkConstraints": {}
1037
+
},
1038
+
"users": {
1039
+
"name": "users",
1040
+
"columns": {
1041
+
"id": {
1042
+
"name": "id",
1043
+
"type": "text",
1044
+
"primaryKey": true,
1045
+
"notNull": true,
1046
+
"autoincrement": false
1047
+
},
1048
+
"did": {
1049
+
"name": "did",
1050
+
"type": "text",
1051
+
"primaryKey": false,
1052
+
"notNull": true,
1053
+
"autoincrement": false
1054
+
},
1055
+
"display_name": {
1056
+
"name": "display_name",
1057
+
"type": "text",
1058
+
"primaryKey": false,
1059
+
"notNull": false,
1060
+
"autoincrement": false
1061
+
},
1062
+
"handle": {
1063
+
"name": "handle",
1064
+
"type": "text",
1065
+
"primaryKey": false,
1066
+
"notNull": true,
1067
+
"autoincrement": false
1068
+
},
1069
+
"avatar": {
1070
+
"name": "avatar",
1071
+
"type": "text",
1072
+
"primaryKey": false,
1073
+
"notNull": true,
1074
+
"autoincrement": false
1075
+
},
1076
+
"created_at": {
1077
+
"name": "created_at",
1078
+
"type": "integer",
1079
+
"primaryKey": false,
1080
+
"notNull": true,
1081
+
"autoincrement": false,
1082
+
"default": "CURRENT_TIMESTAMP"
1083
+
},
1084
+
"updated_at": {
1085
+
"name": "updated_at",
1086
+
"type": "integer",
1087
+
"primaryKey": false,
1088
+
"notNull": true,
1089
+
"autoincrement": false,
1090
+
"default": "CURRENT_TIMESTAMP"
1091
+
}
1092
+
},
1093
+
"indexes": {
1094
+
"users_did_unique": {
1095
+
"name": "users_did_unique",
1096
+
"columns": [
1097
+
"did"
1098
+
],
1099
+
"isUnique": true
1100
+
},
1101
+
"users_handle_unique": {
1102
+
"name": "users_handle_unique",
1103
+
"columns": [
1104
+
"handle"
1105
+
],
1106
+
"isUnique": true
1107
+
}
1108
+
},
1109
+
"foreignKeys": {},
1110
+
"compositePrimaryKeys": {},
1111
+
"uniqueConstraints": {},
1112
+
"checkConstraints": {}
1113
+
}
1114
+
},
1115
+
"views": {},
1116
+
"enums": {},
1117
+
"_meta": {
1118
+
"schemas": {},
1119
+
"tables": {},
1120
+
"columns": {}
1121
+
},
1122
+
"internal": {
1123
+
"indexes": {}
1124
+
}
1125
+
}
+13
apps/cli/drizzle/meta/_journal.json
+13
apps/cli/drizzle/meta/_journal.json
+1
apps/cli/lexicons
+1
apps/cli/lexicons
···
1
+
../api/lexicons
+18
-1
apps/cli/package.json
+18
-1
apps/cli/package.json
···
8
8
"rocksky": "./dist/index.js"
9
9
},
10
10
"scripts": {
11
+
"lexgen": "lex gen-server ./src/lexicon ./lexicons/**/* ./lexicons/*",
11
12
"test": "echo \"Error: no test specified\" && exit 1",
12
13
"dev": "tsx ./src/index.ts",
13
14
"build": "pkgroll && chmod +x ./dist/index.js"
···
22
23
"author": "Tsiry Sandratraina <tsiry.sndr@rocksky.app>",
23
24
"license": "Apache-2.0",
24
25
"dependencies": {
26
+
"@atcute/jetstream": "^1.1.2",
27
+
"@atproto/api": "^0.13.31",
28
+
"@atproto/common": "^0.4.6",
29
+
"@atproto/identity": "^0.4.5",
30
+
"@atproto/jwk-jose": "0.1.5",
31
+
"@atproto/lex-cli": "^0.5.6",
32
+
"@atproto/lexicon": "^0.4.5",
33
+
"@atproto/sync": "^0.1.11",
34
+
"@atproto/syntax": "^0.3.1",
25
35
"@modelcontextprotocol/sdk": "^1.10.2",
36
+
"@paralleldrive/cuid2": "^3.0.6",
37
+
"@types/better-sqlite3": "^7.6.13",
26
38
"axios": "^1.8.4",
39
+
"better-sqlite3": "^12.4.1",
27
40
"chalk": "^5.4.1",
28
41
"commander": "^13.1.0",
29
42
"cors": "^2.8.5",
30
43
"dayjs": "^1.11.13",
44
+
"drizzle-kit": "^0.31.1",
45
+
"drizzle-orm": "^0.45.1",
46
+
"effect": "^3.19.14",
47
+
"env-paths": "^3.0.0",
31
48
"express": "^5.1.0",
32
49
"md5": "^2.3.0",
33
50
"open": "^10.1.0",
···
46
63
"import": "./dist/index.js"
47
64
}
48
65
}
49
-
}
66
+
}
+5
apps/cli/src/context.ts
+5
apps/cli/src/context.ts
+10
apps/cli/src/drizzle.ts
+10
apps/cli/src/drizzle.ts
···
1
+
import { drizzle } from "drizzle-orm/better-sqlite3";
2
+
import envpaths from "env-paths";
3
+
import fs from "node:fs";
4
+
5
+
fs.mkdirSync(envpaths("rocksky", { suffix: "" }).data, { recursive: true });
6
+
const url = `${envpaths("rocksky", { suffix: "" }).data}/rocksky.sqlite`;
7
+
8
+
const db = drizzle(url);
9
+
10
+
export default { db };
apps/cli/src/jetstream.ts
apps/cli/src/jetstream.ts
This is a binary file and will not be displayed.
+1321
apps/cli/src/lexicon/index.ts
+1321
apps/cli/src/lexicon/index.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import {
5
+
createServer as createXrpcServer,
6
+
Server as XrpcServer,
7
+
Options as XrpcOptions,
8
+
AuthVerifier,
9
+
StreamAuthVerifier,
10
+
} from '@atproto/xrpc-server'
11
+
import { schemas } from './lexicons'
12
+
import * as AppRockskyActorGetActorAlbums from './types/app/rocksky/actor/getActorAlbums'
13
+
import * as AppRockskyActorGetActorArtists from './types/app/rocksky/actor/getActorArtists'
14
+
import * as AppRockskyActorGetActorCompatibility from './types/app/rocksky/actor/getActorCompatibility'
15
+
import * as AppRockskyActorGetActorLovedSongs from './types/app/rocksky/actor/getActorLovedSongs'
16
+
import * as AppRockskyActorGetActorNeighbours from './types/app/rocksky/actor/getActorNeighbours'
17
+
import * as AppRockskyActorGetActorPlaylists from './types/app/rocksky/actor/getActorPlaylists'
18
+
import * as AppRockskyActorGetActorScrobbles from './types/app/rocksky/actor/getActorScrobbles'
19
+
import * as AppRockskyActorGetActorSongs from './types/app/rocksky/actor/getActorSongs'
20
+
import * as AppRockskyActorGetProfile from './types/app/rocksky/actor/getProfile'
21
+
import * as AppRockskyAlbumGetAlbum from './types/app/rocksky/album/getAlbum'
22
+
import * as AppRockskyAlbumGetAlbums from './types/app/rocksky/album/getAlbums'
23
+
import * as AppRockskyAlbumGetAlbumTracks from './types/app/rocksky/album/getAlbumTracks'
24
+
import * as AppRockskyApikeyCreateApikey from './types/app/rocksky/apikey/createApikey'
25
+
import * as AppRockskyApikeyGetApikeys from './types/app/rocksky/apikey/getApikeys'
26
+
import * as AppRockskyApikeyRemoveApikey from './types/app/rocksky/apikey/removeApikey'
27
+
import * as AppRockskyApikeyUpdateApikey from './types/app/rocksky/apikey/updateApikey'
28
+
import * as AppRockskyArtistGetArtist from './types/app/rocksky/artist/getArtist'
29
+
import * as AppRockskyArtistGetArtistAlbums from './types/app/rocksky/artist/getArtistAlbums'
30
+
import * as AppRockskyArtistGetArtistListeners from './types/app/rocksky/artist/getArtistListeners'
31
+
import * as AppRockskyArtistGetArtists from './types/app/rocksky/artist/getArtists'
32
+
import * as AppRockskyArtistGetArtistTracks from './types/app/rocksky/artist/getArtistTracks'
33
+
import * as AppRockskyChartsGetScrobblesChart from './types/app/rocksky/charts/getScrobblesChart'
34
+
import * as AppRockskyDropboxDownloadFile from './types/app/rocksky/dropbox/downloadFile'
35
+
import * as AppRockskyDropboxGetFiles from './types/app/rocksky/dropbox/getFiles'
36
+
import * as AppRockskyDropboxGetMetadata from './types/app/rocksky/dropbox/getMetadata'
37
+
import * as AppRockskyDropboxGetTemporaryLink from './types/app/rocksky/dropbox/getTemporaryLink'
38
+
import * as AppRockskyFeedDescribeFeedGenerator from './types/app/rocksky/feed/describeFeedGenerator'
39
+
import * as AppRockskyFeedGetFeed from './types/app/rocksky/feed/getFeed'
40
+
import * as AppRockskyFeedGetFeedGenerator from './types/app/rocksky/feed/getFeedGenerator'
41
+
import * as AppRockskyFeedGetFeedGenerators from './types/app/rocksky/feed/getFeedGenerators'
42
+
import * as AppRockskyFeedGetFeedSkeleton from './types/app/rocksky/feed/getFeedSkeleton'
43
+
import * as AppRockskyFeedGetNowPlayings from './types/app/rocksky/feed/getNowPlayings'
44
+
import * as AppRockskyFeedSearch from './types/app/rocksky/feed/search'
45
+
import * as AppRockskyGoogledriveDownloadFile from './types/app/rocksky/googledrive/downloadFile'
46
+
import * as AppRockskyGoogledriveGetFile from './types/app/rocksky/googledrive/getFile'
47
+
import * as AppRockskyGoogledriveGetFiles from './types/app/rocksky/googledrive/getFiles'
48
+
import * as AppRockskyGraphFollowAccount from './types/app/rocksky/graph/followAccount'
49
+
import * as AppRockskyGraphGetFollowers from './types/app/rocksky/graph/getFollowers'
50
+
import * as AppRockskyGraphGetFollows from './types/app/rocksky/graph/getFollows'
51
+
import * as AppRockskyGraphGetKnownFollowers from './types/app/rocksky/graph/getKnownFollowers'
52
+
import * as AppRockskyGraphUnfollowAccount from './types/app/rocksky/graph/unfollowAccount'
53
+
import * as AppRockskyLikeDislikeShout from './types/app/rocksky/like/dislikeShout'
54
+
import * as AppRockskyLikeDislikeSong from './types/app/rocksky/like/dislikeSong'
55
+
import * as AppRockskyLikeLikeShout from './types/app/rocksky/like/likeShout'
56
+
import * as AppRockskyLikeLikeSong from './types/app/rocksky/like/likeSong'
57
+
import * as AppRockskyPlayerAddDirectoryToQueue from './types/app/rocksky/player/addDirectoryToQueue'
58
+
import * as AppRockskyPlayerAddItemsToQueue from './types/app/rocksky/player/addItemsToQueue'
59
+
import * as AppRockskyPlayerGetCurrentlyPlaying from './types/app/rocksky/player/getCurrentlyPlaying'
60
+
import * as AppRockskyPlayerGetPlaybackQueue from './types/app/rocksky/player/getPlaybackQueue'
61
+
import * as AppRockskyPlayerNext from './types/app/rocksky/player/next'
62
+
import * as AppRockskyPlayerPause from './types/app/rocksky/player/pause'
63
+
import * as AppRockskyPlayerPlay from './types/app/rocksky/player/play'
64
+
import * as AppRockskyPlayerPlayDirectory from './types/app/rocksky/player/playDirectory'
65
+
import * as AppRockskyPlayerPlayFile from './types/app/rocksky/player/playFile'
66
+
import * as AppRockskyPlayerPrevious from './types/app/rocksky/player/previous'
67
+
import * as AppRockskyPlayerSeek from './types/app/rocksky/player/seek'
68
+
import * as AppRockskyPlaylistCreatePlaylist from './types/app/rocksky/playlist/createPlaylist'
69
+
import * as AppRockskyPlaylistGetPlaylist from './types/app/rocksky/playlist/getPlaylist'
70
+
import * as AppRockskyPlaylistGetPlaylists from './types/app/rocksky/playlist/getPlaylists'
71
+
import * as AppRockskyPlaylistInsertDirectory from './types/app/rocksky/playlist/insertDirectory'
72
+
import * as AppRockskyPlaylistInsertFiles from './types/app/rocksky/playlist/insertFiles'
73
+
import * as AppRockskyPlaylistRemovePlaylist from './types/app/rocksky/playlist/removePlaylist'
74
+
import * as AppRockskyPlaylistRemoveTrack from './types/app/rocksky/playlist/removeTrack'
75
+
import * as AppRockskyPlaylistStartPlaylist from './types/app/rocksky/playlist/startPlaylist'
76
+
import * as AppRockskyScrobbleCreateScrobble from './types/app/rocksky/scrobble/createScrobble'
77
+
import * as AppRockskyScrobbleGetScrobble from './types/app/rocksky/scrobble/getScrobble'
78
+
import * as AppRockskyScrobbleGetScrobbles from './types/app/rocksky/scrobble/getScrobbles'
79
+
import * as AppRockskyShoutCreateShout from './types/app/rocksky/shout/createShout'
80
+
import * as AppRockskyShoutGetAlbumShouts from './types/app/rocksky/shout/getAlbumShouts'
81
+
import * as AppRockskyShoutGetArtistShouts from './types/app/rocksky/shout/getArtistShouts'
82
+
import * as AppRockskyShoutGetProfileShouts from './types/app/rocksky/shout/getProfileShouts'
83
+
import * as AppRockskyShoutGetShoutReplies from './types/app/rocksky/shout/getShoutReplies'
84
+
import * as AppRockskyShoutGetTrackShouts from './types/app/rocksky/shout/getTrackShouts'
85
+
import * as AppRockskyShoutRemoveShout from './types/app/rocksky/shout/removeShout'
86
+
import * as AppRockskyShoutReplyShout from './types/app/rocksky/shout/replyShout'
87
+
import * as AppRockskyShoutReportShout from './types/app/rocksky/shout/reportShout'
88
+
import * as AppRockskySongCreateSong from './types/app/rocksky/song/createSong'
89
+
import * as AppRockskySongGetSong from './types/app/rocksky/song/getSong'
90
+
import * as AppRockskySongGetSongs from './types/app/rocksky/song/getSongs'
91
+
import * as AppRockskySpotifyGetCurrentlyPlaying from './types/app/rocksky/spotify/getCurrentlyPlaying'
92
+
import * as AppRockskySpotifyNext from './types/app/rocksky/spotify/next'
93
+
import * as AppRockskySpotifyPause from './types/app/rocksky/spotify/pause'
94
+
import * as AppRockskySpotifyPlay from './types/app/rocksky/spotify/play'
95
+
import * as AppRockskySpotifyPrevious from './types/app/rocksky/spotify/previous'
96
+
import * as AppRockskySpotifySeek from './types/app/rocksky/spotify/seek'
97
+
import * as AppRockskyStatsGetStats from './types/app/rocksky/stats/getStats'
98
+
99
+
export function createServer(options?: XrpcOptions): Server {
100
+
return new Server(options)
101
+
}
102
+
103
+
export class Server {
104
+
xrpc: XrpcServer
105
+
app: AppNS
106
+
com: ComNS
107
+
108
+
constructor(options?: XrpcOptions) {
109
+
this.xrpc = createXrpcServer(schemas, options)
110
+
this.app = new AppNS(this)
111
+
this.com = new ComNS(this)
112
+
}
113
+
}
114
+
115
+
export class AppNS {
116
+
_server: Server
117
+
rocksky: AppRockskyNS
118
+
bsky: AppBskyNS
119
+
120
+
constructor(server: Server) {
121
+
this._server = server
122
+
this.rocksky = new AppRockskyNS(server)
123
+
this.bsky = new AppBskyNS(server)
124
+
}
125
+
}
126
+
127
+
export class AppRockskyNS {
128
+
_server: Server
129
+
actor: AppRockskyActorNS
130
+
album: AppRockskyAlbumNS
131
+
apikey: AppRockskyApikeyNS
132
+
artist: AppRockskyArtistNS
133
+
charts: AppRockskyChartsNS
134
+
dropbox: AppRockskyDropboxNS
135
+
feed: AppRockskyFeedNS
136
+
googledrive: AppRockskyGoogledriveNS
137
+
graph: AppRockskyGraphNS
138
+
like: AppRockskyLikeNS
139
+
player: AppRockskyPlayerNS
140
+
playlist: AppRockskyPlaylistNS
141
+
scrobble: AppRockskyScrobbleNS
142
+
shout: AppRockskyShoutNS
143
+
song: AppRockskySongNS
144
+
spotify: AppRockskySpotifyNS
145
+
stats: AppRockskyStatsNS
146
+
147
+
constructor(server: Server) {
148
+
this._server = server
149
+
this.actor = new AppRockskyActorNS(server)
150
+
this.album = new AppRockskyAlbumNS(server)
151
+
this.apikey = new AppRockskyApikeyNS(server)
152
+
this.artist = new AppRockskyArtistNS(server)
153
+
this.charts = new AppRockskyChartsNS(server)
154
+
this.dropbox = new AppRockskyDropboxNS(server)
155
+
this.feed = new AppRockskyFeedNS(server)
156
+
this.googledrive = new AppRockskyGoogledriveNS(server)
157
+
this.graph = new AppRockskyGraphNS(server)
158
+
this.like = new AppRockskyLikeNS(server)
159
+
this.player = new AppRockskyPlayerNS(server)
160
+
this.playlist = new AppRockskyPlaylistNS(server)
161
+
this.scrobble = new AppRockskyScrobbleNS(server)
162
+
this.shout = new AppRockskyShoutNS(server)
163
+
this.song = new AppRockskySongNS(server)
164
+
this.spotify = new AppRockskySpotifyNS(server)
165
+
this.stats = new AppRockskyStatsNS(server)
166
+
}
167
+
}
168
+
169
+
export class AppRockskyActorNS {
170
+
_server: Server
171
+
172
+
constructor(server: Server) {
173
+
this._server = server
174
+
}
175
+
176
+
getActorAlbums<AV extends AuthVerifier>(
177
+
cfg: ConfigOf<
178
+
AV,
179
+
AppRockskyActorGetActorAlbums.Handler<ExtractAuth<AV>>,
180
+
AppRockskyActorGetActorAlbums.HandlerReqCtx<ExtractAuth<AV>>
181
+
>,
182
+
) {
183
+
const nsid = 'app.rocksky.actor.getActorAlbums' // @ts-ignore
184
+
return this._server.xrpc.method(nsid, cfg)
185
+
}
186
+
187
+
getActorArtists<AV extends AuthVerifier>(
188
+
cfg: ConfigOf<
189
+
AV,
190
+
AppRockskyActorGetActorArtists.Handler<ExtractAuth<AV>>,
191
+
AppRockskyActorGetActorArtists.HandlerReqCtx<ExtractAuth<AV>>
192
+
>,
193
+
) {
194
+
const nsid = 'app.rocksky.actor.getActorArtists' // @ts-ignore
195
+
return this._server.xrpc.method(nsid, cfg)
196
+
}
197
+
198
+
getActorCompatibility<AV extends AuthVerifier>(
199
+
cfg: ConfigOf<
200
+
AV,
201
+
AppRockskyActorGetActorCompatibility.Handler<ExtractAuth<AV>>,
202
+
AppRockskyActorGetActorCompatibility.HandlerReqCtx<ExtractAuth<AV>>
203
+
>,
204
+
) {
205
+
const nsid = 'app.rocksky.actor.getActorCompatibility' // @ts-ignore
206
+
return this._server.xrpc.method(nsid, cfg)
207
+
}
208
+
209
+
getActorLovedSongs<AV extends AuthVerifier>(
210
+
cfg: ConfigOf<
211
+
AV,
212
+
AppRockskyActorGetActorLovedSongs.Handler<ExtractAuth<AV>>,
213
+
AppRockskyActorGetActorLovedSongs.HandlerReqCtx<ExtractAuth<AV>>
214
+
>,
215
+
) {
216
+
const nsid = 'app.rocksky.actor.getActorLovedSongs' // @ts-ignore
217
+
return this._server.xrpc.method(nsid, cfg)
218
+
}
219
+
220
+
getActorNeighbours<AV extends AuthVerifier>(
221
+
cfg: ConfigOf<
222
+
AV,
223
+
AppRockskyActorGetActorNeighbours.Handler<ExtractAuth<AV>>,
224
+
AppRockskyActorGetActorNeighbours.HandlerReqCtx<ExtractAuth<AV>>
225
+
>,
226
+
) {
227
+
const nsid = 'app.rocksky.actor.getActorNeighbours' // @ts-ignore
228
+
return this._server.xrpc.method(nsid, cfg)
229
+
}
230
+
231
+
getActorPlaylists<AV extends AuthVerifier>(
232
+
cfg: ConfigOf<
233
+
AV,
234
+
AppRockskyActorGetActorPlaylists.Handler<ExtractAuth<AV>>,
235
+
AppRockskyActorGetActorPlaylists.HandlerReqCtx<ExtractAuth<AV>>
236
+
>,
237
+
) {
238
+
const nsid = 'app.rocksky.actor.getActorPlaylists' // @ts-ignore
239
+
return this._server.xrpc.method(nsid, cfg)
240
+
}
241
+
242
+
getActorScrobbles<AV extends AuthVerifier>(
243
+
cfg: ConfigOf<
244
+
AV,
245
+
AppRockskyActorGetActorScrobbles.Handler<ExtractAuth<AV>>,
246
+
AppRockskyActorGetActorScrobbles.HandlerReqCtx<ExtractAuth<AV>>
247
+
>,
248
+
) {
249
+
const nsid = 'app.rocksky.actor.getActorScrobbles' // @ts-ignore
250
+
return this._server.xrpc.method(nsid, cfg)
251
+
}
252
+
253
+
getActorSongs<AV extends AuthVerifier>(
254
+
cfg: ConfigOf<
255
+
AV,
256
+
AppRockskyActorGetActorSongs.Handler<ExtractAuth<AV>>,
257
+
AppRockskyActorGetActorSongs.HandlerReqCtx<ExtractAuth<AV>>
258
+
>,
259
+
) {
260
+
const nsid = 'app.rocksky.actor.getActorSongs' // @ts-ignore
261
+
return this._server.xrpc.method(nsid, cfg)
262
+
}
263
+
264
+
getProfile<AV extends AuthVerifier>(
265
+
cfg: ConfigOf<
266
+
AV,
267
+
AppRockskyActorGetProfile.Handler<ExtractAuth<AV>>,
268
+
AppRockskyActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
269
+
>,
270
+
) {
271
+
const nsid = 'app.rocksky.actor.getProfile' // @ts-ignore
272
+
return this._server.xrpc.method(nsid, cfg)
273
+
}
274
+
}
275
+
276
+
export class AppRockskyAlbumNS {
277
+
_server: Server
278
+
279
+
constructor(server: Server) {
280
+
this._server = server
281
+
}
282
+
283
+
getAlbum<AV extends AuthVerifier>(
284
+
cfg: ConfigOf<
285
+
AV,
286
+
AppRockskyAlbumGetAlbum.Handler<ExtractAuth<AV>>,
287
+
AppRockskyAlbumGetAlbum.HandlerReqCtx<ExtractAuth<AV>>
288
+
>,
289
+
) {
290
+
const nsid = 'app.rocksky.album.getAlbum' // @ts-ignore
291
+
return this._server.xrpc.method(nsid, cfg)
292
+
}
293
+
294
+
getAlbums<AV extends AuthVerifier>(
295
+
cfg: ConfigOf<
296
+
AV,
297
+
AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
298
+
AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
299
+
>,
300
+
) {
301
+
const nsid = 'app.rocksky.album.getAlbums' // @ts-ignore
302
+
return this._server.xrpc.method(nsid, cfg)
303
+
}
304
+
305
+
getAlbumTracks<AV extends AuthVerifier>(
306
+
cfg: ConfigOf<
307
+
AV,
308
+
AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
309
+
AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
310
+
>,
311
+
) {
312
+
const nsid = 'app.rocksky.album.getAlbumTracks' // @ts-ignore
313
+
return this._server.xrpc.method(nsid, cfg)
314
+
}
315
+
}
316
+
317
+
export class AppRockskyApikeyNS {
318
+
_server: Server
319
+
320
+
constructor(server: Server) {
321
+
this._server = server
322
+
}
323
+
324
+
createApikey<AV extends AuthVerifier>(
325
+
cfg: ConfigOf<
326
+
AV,
327
+
AppRockskyApikeyCreateApikey.Handler<ExtractAuth<AV>>,
328
+
AppRockskyApikeyCreateApikey.HandlerReqCtx<ExtractAuth<AV>>
329
+
>,
330
+
) {
331
+
const nsid = 'app.rocksky.apikey.createApikey' // @ts-ignore
332
+
return this._server.xrpc.method(nsid, cfg)
333
+
}
334
+
335
+
getApikeys<AV extends AuthVerifier>(
336
+
cfg: ConfigOf<
337
+
AV,
338
+
AppRockskyApikeyGetApikeys.Handler<ExtractAuth<AV>>,
339
+
AppRockskyApikeyGetApikeys.HandlerReqCtx<ExtractAuth<AV>>
340
+
>,
341
+
) {
342
+
const nsid = 'app.rocksky.apikey.getApikeys' // @ts-ignore
343
+
return this._server.xrpc.method(nsid, cfg)
344
+
}
345
+
346
+
removeApikey<AV extends AuthVerifier>(
347
+
cfg: ConfigOf<
348
+
AV,
349
+
AppRockskyApikeyRemoveApikey.Handler<ExtractAuth<AV>>,
350
+
AppRockskyApikeyRemoveApikey.HandlerReqCtx<ExtractAuth<AV>>
351
+
>,
352
+
) {
353
+
const nsid = 'app.rocksky.apikey.removeApikey' // @ts-ignore
354
+
return this._server.xrpc.method(nsid, cfg)
355
+
}
356
+
357
+
updateApikey<AV extends AuthVerifier>(
358
+
cfg: ConfigOf<
359
+
AV,
360
+
AppRockskyApikeyUpdateApikey.Handler<ExtractAuth<AV>>,
361
+
AppRockskyApikeyUpdateApikey.HandlerReqCtx<ExtractAuth<AV>>
362
+
>,
363
+
) {
364
+
const nsid = 'app.rocksky.apikey.updateApikey' // @ts-ignore
365
+
return this._server.xrpc.method(nsid, cfg)
366
+
}
367
+
}
368
+
369
+
export class AppRockskyArtistNS {
370
+
_server: Server
371
+
372
+
constructor(server: Server) {
373
+
this._server = server
374
+
}
375
+
376
+
getArtist<AV extends AuthVerifier>(
377
+
cfg: ConfigOf<
378
+
AV,
379
+
AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
380
+
AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
381
+
>,
382
+
) {
383
+
const nsid = 'app.rocksky.artist.getArtist' // @ts-ignore
384
+
return this._server.xrpc.method(nsid, cfg)
385
+
}
386
+
387
+
getArtistAlbums<AV extends AuthVerifier>(
388
+
cfg: ConfigOf<
389
+
AV,
390
+
AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
391
+
AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
392
+
>,
393
+
) {
394
+
const nsid = 'app.rocksky.artist.getArtistAlbums' // @ts-ignore
395
+
return this._server.xrpc.method(nsid, cfg)
396
+
}
397
+
398
+
getArtistListeners<AV extends AuthVerifier>(
399
+
cfg: ConfigOf<
400
+
AV,
401
+
AppRockskyArtistGetArtistListeners.Handler<ExtractAuth<AV>>,
402
+
AppRockskyArtistGetArtistListeners.HandlerReqCtx<ExtractAuth<AV>>
403
+
>,
404
+
) {
405
+
const nsid = 'app.rocksky.artist.getArtistListeners' // @ts-ignore
406
+
return this._server.xrpc.method(nsid, cfg)
407
+
}
408
+
409
+
getArtists<AV extends AuthVerifier>(
410
+
cfg: ConfigOf<
411
+
AV,
412
+
AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
413
+
AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
414
+
>,
415
+
) {
416
+
const nsid = 'app.rocksky.artist.getArtists' // @ts-ignore
417
+
return this._server.xrpc.method(nsid, cfg)
418
+
}
419
+
420
+
getArtistTracks<AV extends AuthVerifier>(
421
+
cfg: ConfigOf<
422
+
AV,
423
+
AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
424
+
AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
425
+
>,
426
+
) {
427
+
const nsid = 'app.rocksky.artist.getArtistTracks' // @ts-ignore
428
+
return this._server.xrpc.method(nsid, cfg)
429
+
}
430
+
}
431
+
432
+
export class AppRockskyChartsNS {
433
+
_server: Server
434
+
435
+
constructor(server: Server) {
436
+
this._server = server
437
+
}
438
+
439
+
getScrobblesChart<AV extends AuthVerifier>(
440
+
cfg: ConfigOf<
441
+
AV,
442
+
AppRockskyChartsGetScrobblesChart.Handler<ExtractAuth<AV>>,
443
+
AppRockskyChartsGetScrobblesChart.HandlerReqCtx<ExtractAuth<AV>>
444
+
>,
445
+
) {
446
+
const nsid = 'app.rocksky.charts.getScrobblesChart' // @ts-ignore
447
+
return this._server.xrpc.method(nsid, cfg)
448
+
}
449
+
}
450
+
451
+
export class AppRockskyDropboxNS {
452
+
_server: Server
453
+
454
+
constructor(server: Server) {
455
+
this._server = server
456
+
}
457
+
458
+
downloadFile<AV extends AuthVerifier>(
459
+
cfg: ConfigOf<
460
+
AV,
461
+
AppRockskyDropboxDownloadFile.Handler<ExtractAuth<AV>>,
462
+
AppRockskyDropboxDownloadFile.HandlerReqCtx<ExtractAuth<AV>>
463
+
>,
464
+
) {
465
+
const nsid = 'app.rocksky.dropbox.downloadFile' // @ts-ignore
466
+
return this._server.xrpc.method(nsid, cfg)
467
+
}
468
+
469
+
getFiles<AV extends AuthVerifier>(
470
+
cfg: ConfigOf<
471
+
AV,
472
+
AppRockskyDropboxGetFiles.Handler<ExtractAuth<AV>>,
473
+
AppRockskyDropboxGetFiles.HandlerReqCtx<ExtractAuth<AV>>
474
+
>,
475
+
) {
476
+
const nsid = 'app.rocksky.dropbox.getFiles' // @ts-ignore
477
+
return this._server.xrpc.method(nsid, cfg)
478
+
}
479
+
480
+
getMetadata<AV extends AuthVerifier>(
481
+
cfg: ConfigOf<
482
+
AV,
483
+
AppRockskyDropboxGetMetadata.Handler<ExtractAuth<AV>>,
484
+
AppRockskyDropboxGetMetadata.HandlerReqCtx<ExtractAuth<AV>>
485
+
>,
486
+
) {
487
+
const nsid = 'app.rocksky.dropbox.getMetadata' // @ts-ignore
488
+
return this._server.xrpc.method(nsid, cfg)
489
+
}
490
+
491
+
getTemporaryLink<AV extends AuthVerifier>(
492
+
cfg: ConfigOf<
493
+
AV,
494
+
AppRockskyDropboxGetTemporaryLink.Handler<ExtractAuth<AV>>,
495
+
AppRockskyDropboxGetTemporaryLink.HandlerReqCtx<ExtractAuth<AV>>
496
+
>,
497
+
) {
498
+
const nsid = 'app.rocksky.dropbox.getTemporaryLink' // @ts-ignore
499
+
return this._server.xrpc.method(nsid, cfg)
500
+
}
501
+
}
502
+
503
+
export class AppRockskyFeedNS {
504
+
_server: Server
505
+
506
+
constructor(server: Server) {
507
+
this._server = server
508
+
}
509
+
510
+
describeFeedGenerator<AV extends AuthVerifier>(
511
+
cfg: ConfigOf<
512
+
AV,
513
+
AppRockskyFeedDescribeFeedGenerator.Handler<ExtractAuth<AV>>,
514
+
AppRockskyFeedDescribeFeedGenerator.HandlerReqCtx<ExtractAuth<AV>>
515
+
>,
516
+
) {
517
+
const nsid = 'app.rocksky.feed.describeFeedGenerator' // @ts-ignore
518
+
return this._server.xrpc.method(nsid, cfg)
519
+
}
520
+
521
+
getFeed<AV extends AuthVerifier>(
522
+
cfg: ConfigOf<
523
+
AV,
524
+
AppRockskyFeedGetFeed.Handler<ExtractAuth<AV>>,
525
+
AppRockskyFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>>
526
+
>,
527
+
) {
528
+
const nsid = 'app.rocksky.feed.getFeed' // @ts-ignore
529
+
return this._server.xrpc.method(nsid, cfg)
530
+
}
531
+
532
+
getFeedGenerator<AV extends AuthVerifier>(
533
+
cfg: ConfigOf<
534
+
AV,
535
+
AppRockskyFeedGetFeedGenerator.Handler<ExtractAuth<AV>>,
536
+
AppRockskyFeedGetFeedGenerator.HandlerReqCtx<ExtractAuth<AV>>
537
+
>,
538
+
) {
539
+
const nsid = 'app.rocksky.feed.getFeedGenerator' // @ts-ignore
540
+
return this._server.xrpc.method(nsid, cfg)
541
+
}
542
+
543
+
getFeedGenerators<AV extends AuthVerifier>(
544
+
cfg: ConfigOf<
545
+
AV,
546
+
AppRockskyFeedGetFeedGenerators.Handler<ExtractAuth<AV>>,
547
+
AppRockskyFeedGetFeedGenerators.HandlerReqCtx<ExtractAuth<AV>>
548
+
>,
549
+
) {
550
+
const nsid = 'app.rocksky.feed.getFeedGenerators' // @ts-ignore
551
+
return this._server.xrpc.method(nsid, cfg)
552
+
}
553
+
554
+
getFeedSkeleton<AV extends AuthVerifier>(
555
+
cfg: ConfigOf<
556
+
AV,
557
+
AppRockskyFeedGetFeedSkeleton.Handler<ExtractAuth<AV>>,
558
+
AppRockskyFeedGetFeedSkeleton.HandlerReqCtx<ExtractAuth<AV>>
559
+
>,
560
+
) {
561
+
const nsid = 'app.rocksky.feed.getFeedSkeleton' // @ts-ignore
562
+
return this._server.xrpc.method(nsid, cfg)
563
+
}
564
+
565
+
getNowPlayings<AV extends AuthVerifier>(
566
+
cfg: ConfigOf<
567
+
AV,
568
+
AppRockskyFeedGetNowPlayings.Handler<ExtractAuth<AV>>,
569
+
AppRockskyFeedGetNowPlayings.HandlerReqCtx<ExtractAuth<AV>>
570
+
>,
571
+
) {
572
+
const nsid = 'app.rocksky.feed.getNowPlayings' // @ts-ignore
573
+
return this._server.xrpc.method(nsid, cfg)
574
+
}
575
+
576
+
search<AV extends AuthVerifier>(
577
+
cfg: ConfigOf<
578
+
AV,
579
+
AppRockskyFeedSearch.Handler<ExtractAuth<AV>>,
580
+
AppRockskyFeedSearch.HandlerReqCtx<ExtractAuth<AV>>
581
+
>,
582
+
) {
583
+
const nsid = 'app.rocksky.feed.search' // @ts-ignore
584
+
return this._server.xrpc.method(nsid, cfg)
585
+
}
586
+
}
587
+
588
+
export class AppRockskyGoogledriveNS {
589
+
_server: Server
590
+
591
+
constructor(server: Server) {
592
+
this._server = server
593
+
}
594
+
595
+
downloadFile<AV extends AuthVerifier>(
596
+
cfg: ConfigOf<
597
+
AV,
598
+
AppRockskyGoogledriveDownloadFile.Handler<ExtractAuth<AV>>,
599
+
AppRockskyGoogledriveDownloadFile.HandlerReqCtx<ExtractAuth<AV>>
600
+
>,
601
+
) {
602
+
const nsid = 'app.rocksky.googledrive.downloadFile' // @ts-ignore
603
+
return this._server.xrpc.method(nsid, cfg)
604
+
}
605
+
606
+
getFile<AV extends AuthVerifier>(
607
+
cfg: ConfigOf<
608
+
AV,
609
+
AppRockskyGoogledriveGetFile.Handler<ExtractAuth<AV>>,
610
+
AppRockskyGoogledriveGetFile.HandlerReqCtx<ExtractAuth<AV>>
611
+
>,
612
+
) {
613
+
const nsid = 'app.rocksky.googledrive.getFile' // @ts-ignore
614
+
return this._server.xrpc.method(nsid, cfg)
615
+
}
616
+
617
+
getFiles<AV extends AuthVerifier>(
618
+
cfg: ConfigOf<
619
+
AV,
620
+
AppRockskyGoogledriveGetFiles.Handler<ExtractAuth<AV>>,
621
+
AppRockskyGoogledriveGetFiles.HandlerReqCtx<ExtractAuth<AV>>
622
+
>,
623
+
) {
624
+
const nsid = 'app.rocksky.googledrive.getFiles' // @ts-ignore
625
+
return this._server.xrpc.method(nsid, cfg)
626
+
}
627
+
}
628
+
629
+
export class AppRockskyGraphNS {
630
+
_server: Server
631
+
632
+
constructor(server: Server) {
633
+
this._server = server
634
+
}
635
+
636
+
followAccount<AV extends AuthVerifier>(
637
+
cfg: ConfigOf<
638
+
AV,
639
+
AppRockskyGraphFollowAccount.Handler<ExtractAuth<AV>>,
640
+
AppRockskyGraphFollowAccount.HandlerReqCtx<ExtractAuth<AV>>
641
+
>,
642
+
) {
643
+
const nsid = 'app.rocksky.graph.followAccount' // @ts-ignore
644
+
return this._server.xrpc.method(nsid, cfg)
645
+
}
646
+
647
+
getFollowers<AV extends AuthVerifier>(
648
+
cfg: ConfigOf<
649
+
AV,
650
+
AppRockskyGraphGetFollowers.Handler<ExtractAuth<AV>>,
651
+
AppRockskyGraphGetFollowers.HandlerReqCtx<ExtractAuth<AV>>
652
+
>,
653
+
) {
654
+
const nsid = 'app.rocksky.graph.getFollowers' // @ts-ignore
655
+
return this._server.xrpc.method(nsid, cfg)
656
+
}
657
+
658
+
getFollows<AV extends AuthVerifier>(
659
+
cfg: ConfigOf<
660
+
AV,
661
+
AppRockskyGraphGetFollows.Handler<ExtractAuth<AV>>,
662
+
AppRockskyGraphGetFollows.HandlerReqCtx<ExtractAuth<AV>>
663
+
>,
664
+
) {
665
+
const nsid = 'app.rocksky.graph.getFollows' // @ts-ignore
666
+
return this._server.xrpc.method(nsid, cfg)
667
+
}
668
+
669
+
getKnownFollowers<AV extends AuthVerifier>(
670
+
cfg: ConfigOf<
671
+
AV,
672
+
AppRockskyGraphGetKnownFollowers.Handler<ExtractAuth<AV>>,
673
+
AppRockskyGraphGetKnownFollowers.HandlerReqCtx<ExtractAuth<AV>>
674
+
>,
675
+
) {
676
+
const nsid = 'app.rocksky.graph.getKnownFollowers' // @ts-ignore
677
+
return this._server.xrpc.method(nsid, cfg)
678
+
}
679
+
680
+
unfollowAccount<AV extends AuthVerifier>(
681
+
cfg: ConfigOf<
682
+
AV,
683
+
AppRockskyGraphUnfollowAccount.Handler<ExtractAuth<AV>>,
684
+
AppRockskyGraphUnfollowAccount.HandlerReqCtx<ExtractAuth<AV>>
685
+
>,
686
+
) {
687
+
const nsid = 'app.rocksky.graph.unfollowAccount' // @ts-ignore
688
+
return this._server.xrpc.method(nsid, cfg)
689
+
}
690
+
}
691
+
692
+
export class AppRockskyLikeNS {
693
+
_server: Server
694
+
695
+
constructor(server: Server) {
696
+
this._server = server
697
+
}
698
+
699
+
dislikeShout<AV extends AuthVerifier>(
700
+
cfg: ConfigOf<
701
+
AV,
702
+
AppRockskyLikeDislikeShout.Handler<ExtractAuth<AV>>,
703
+
AppRockskyLikeDislikeShout.HandlerReqCtx<ExtractAuth<AV>>
704
+
>,
705
+
) {
706
+
const nsid = 'app.rocksky.like.dislikeShout' // @ts-ignore
707
+
return this._server.xrpc.method(nsid, cfg)
708
+
}
709
+
710
+
dislikeSong<AV extends AuthVerifier>(
711
+
cfg: ConfigOf<
712
+
AV,
713
+
AppRockskyLikeDislikeSong.Handler<ExtractAuth<AV>>,
714
+
AppRockskyLikeDislikeSong.HandlerReqCtx<ExtractAuth<AV>>
715
+
>,
716
+
) {
717
+
const nsid = 'app.rocksky.like.dislikeSong' // @ts-ignore
718
+
return this._server.xrpc.method(nsid, cfg)
719
+
}
720
+
721
+
likeShout<AV extends AuthVerifier>(
722
+
cfg: ConfigOf<
723
+
AV,
724
+
AppRockskyLikeLikeShout.Handler<ExtractAuth<AV>>,
725
+
AppRockskyLikeLikeShout.HandlerReqCtx<ExtractAuth<AV>>
726
+
>,
727
+
) {
728
+
const nsid = 'app.rocksky.like.likeShout' // @ts-ignore
729
+
return this._server.xrpc.method(nsid, cfg)
730
+
}
731
+
732
+
likeSong<AV extends AuthVerifier>(
733
+
cfg: ConfigOf<
734
+
AV,
735
+
AppRockskyLikeLikeSong.Handler<ExtractAuth<AV>>,
736
+
AppRockskyLikeLikeSong.HandlerReqCtx<ExtractAuth<AV>>
737
+
>,
738
+
) {
739
+
const nsid = 'app.rocksky.like.likeSong' // @ts-ignore
740
+
return this._server.xrpc.method(nsid, cfg)
741
+
}
742
+
}
743
+
744
+
export class AppRockskyPlayerNS {
745
+
_server: Server
746
+
747
+
constructor(server: Server) {
748
+
this._server = server
749
+
}
750
+
751
+
addDirectoryToQueue<AV extends AuthVerifier>(
752
+
cfg: ConfigOf<
753
+
AV,
754
+
AppRockskyPlayerAddDirectoryToQueue.Handler<ExtractAuth<AV>>,
755
+
AppRockskyPlayerAddDirectoryToQueue.HandlerReqCtx<ExtractAuth<AV>>
756
+
>,
757
+
) {
758
+
const nsid = 'app.rocksky.player.addDirectoryToQueue' // @ts-ignore
759
+
return this._server.xrpc.method(nsid, cfg)
760
+
}
761
+
762
+
addItemsToQueue<AV extends AuthVerifier>(
763
+
cfg: ConfigOf<
764
+
AV,
765
+
AppRockskyPlayerAddItemsToQueue.Handler<ExtractAuth<AV>>,
766
+
AppRockskyPlayerAddItemsToQueue.HandlerReqCtx<ExtractAuth<AV>>
767
+
>,
768
+
) {
769
+
const nsid = 'app.rocksky.player.addItemsToQueue' // @ts-ignore
770
+
return this._server.xrpc.method(nsid, cfg)
771
+
}
772
+
773
+
getCurrentlyPlaying<AV extends AuthVerifier>(
774
+
cfg: ConfigOf<
775
+
AV,
776
+
AppRockskyPlayerGetCurrentlyPlaying.Handler<ExtractAuth<AV>>,
777
+
AppRockskyPlayerGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>>
778
+
>,
779
+
) {
780
+
const nsid = 'app.rocksky.player.getCurrentlyPlaying' // @ts-ignore
781
+
return this._server.xrpc.method(nsid, cfg)
782
+
}
783
+
784
+
getPlaybackQueue<AV extends AuthVerifier>(
785
+
cfg: ConfigOf<
786
+
AV,
787
+
AppRockskyPlayerGetPlaybackQueue.Handler<ExtractAuth<AV>>,
788
+
AppRockskyPlayerGetPlaybackQueue.HandlerReqCtx<ExtractAuth<AV>>
789
+
>,
790
+
) {
791
+
const nsid = 'app.rocksky.player.getPlaybackQueue' // @ts-ignore
792
+
return this._server.xrpc.method(nsid, cfg)
793
+
}
794
+
795
+
next<AV extends AuthVerifier>(
796
+
cfg: ConfigOf<
797
+
AV,
798
+
AppRockskyPlayerNext.Handler<ExtractAuth<AV>>,
799
+
AppRockskyPlayerNext.HandlerReqCtx<ExtractAuth<AV>>
800
+
>,
801
+
) {
802
+
const nsid = 'app.rocksky.player.next' // @ts-ignore
803
+
return this._server.xrpc.method(nsid, cfg)
804
+
}
805
+
806
+
pause<AV extends AuthVerifier>(
807
+
cfg: ConfigOf<
808
+
AV,
809
+
AppRockskyPlayerPause.Handler<ExtractAuth<AV>>,
810
+
AppRockskyPlayerPause.HandlerReqCtx<ExtractAuth<AV>>
811
+
>,
812
+
) {
813
+
const nsid = 'app.rocksky.player.pause' // @ts-ignore
814
+
return this._server.xrpc.method(nsid, cfg)
815
+
}
816
+
817
+
play<AV extends AuthVerifier>(
818
+
cfg: ConfigOf<
819
+
AV,
820
+
AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
821
+
AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
822
+
>,
823
+
) {
824
+
const nsid = 'app.rocksky.player.play' // @ts-ignore
825
+
return this._server.xrpc.method(nsid, cfg)
826
+
}
827
+
828
+
playDirectory<AV extends AuthVerifier>(
829
+
cfg: ConfigOf<
830
+
AV,
831
+
AppRockskyPlayerPlayDirectory.Handler<ExtractAuth<AV>>,
832
+
AppRockskyPlayerPlayDirectory.HandlerReqCtx<ExtractAuth<AV>>
833
+
>,
834
+
) {
835
+
const nsid = 'app.rocksky.player.playDirectory' // @ts-ignore
836
+
return this._server.xrpc.method(nsid, cfg)
837
+
}
838
+
839
+
playFile<AV extends AuthVerifier>(
840
+
cfg: ConfigOf<
841
+
AV,
842
+
AppRockskyPlayerPlayFile.Handler<ExtractAuth<AV>>,
843
+
AppRockskyPlayerPlayFile.HandlerReqCtx<ExtractAuth<AV>>
844
+
>,
845
+
) {
846
+
const nsid = 'app.rocksky.player.playFile' // @ts-ignore
847
+
return this._server.xrpc.method(nsid, cfg)
848
+
}
849
+
850
+
previous<AV extends AuthVerifier>(
851
+
cfg: ConfigOf<
852
+
AV,
853
+
AppRockskyPlayerPrevious.Handler<ExtractAuth<AV>>,
854
+
AppRockskyPlayerPrevious.HandlerReqCtx<ExtractAuth<AV>>
855
+
>,
856
+
) {
857
+
const nsid = 'app.rocksky.player.previous' // @ts-ignore
858
+
return this._server.xrpc.method(nsid, cfg)
859
+
}
860
+
861
+
seek<AV extends AuthVerifier>(
862
+
cfg: ConfigOf<
863
+
AV,
864
+
AppRockskyPlayerSeek.Handler<ExtractAuth<AV>>,
865
+
AppRockskyPlayerSeek.HandlerReqCtx<ExtractAuth<AV>>
866
+
>,
867
+
) {
868
+
const nsid = 'app.rocksky.player.seek' // @ts-ignore
869
+
return this._server.xrpc.method(nsid, cfg)
870
+
}
871
+
}
872
+
873
+
export class AppRockskyPlaylistNS {
874
+
_server: Server
875
+
876
+
constructor(server: Server) {
877
+
this._server = server
878
+
}
879
+
880
+
createPlaylist<AV extends AuthVerifier>(
881
+
cfg: ConfigOf<
882
+
AV,
883
+
AppRockskyPlaylistCreatePlaylist.Handler<ExtractAuth<AV>>,
884
+
AppRockskyPlaylistCreatePlaylist.HandlerReqCtx<ExtractAuth<AV>>
885
+
>,
886
+
) {
887
+
const nsid = 'app.rocksky.playlist.createPlaylist' // @ts-ignore
888
+
return this._server.xrpc.method(nsid, cfg)
889
+
}
890
+
891
+
getPlaylist<AV extends AuthVerifier>(
892
+
cfg: ConfigOf<
893
+
AV,
894
+
AppRockskyPlaylistGetPlaylist.Handler<ExtractAuth<AV>>,
895
+
AppRockskyPlaylistGetPlaylist.HandlerReqCtx<ExtractAuth<AV>>
896
+
>,
897
+
) {
898
+
const nsid = 'app.rocksky.playlist.getPlaylist' // @ts-ignore
899
+
return this._server.xrpc.method(nsid, cfg)
900
+
}
901
+
902
+
getPlaylists<AV extends AuthVerifier>(
903
+
cfg: ConfigOf<
904
+
AV,
905
+
AppRockskyPlaylistGetPlaylists.Handler<ExtractAuth<AV>>,
906
+
AppRockskyPlaylistGetPlaylists.HandlerReqCtx<ExtractAuth<AV>>
907
+
>,
908
+
) {
909
+
const nsid = 'app.rocksky.playlist.getPlaylists' // @ts-ignore
910
+
return this._server.xrpc.method(nsid, cfg)
911
+
}
912
+
913
+
insertDirectory<AV extends AuthVerifier>(
914
+
cfg: ConfigOf<
915
+
AV,
916
+
AppRockskyPlaylistInsertDirectory.Handler<ExtractAuth<AV>>,
917
+
AppRockskyPlaylistInsertDirectory.HandlerReqCtx<ExtractAuth<AV>>
918
+
>,
919
+
) {
920
+
const nsid = 'app.rocksky.playlist.insertDirectory' // @ts-ignore
921
+
return this._server.xrpc.method(nsid, cfg)
922
+
}
923
+
924
+
insertFiles<AV extends AuthVerifier>(
925
+
cfg: ConfigOf<
926
+
AV,
927
+
AppRockskyPlaylistInsertFiles.Handler<ExtractAuth<AV>>,
928
+
AppRockskyPlaylistInsertFiles.HandlerReqCtx<ExtractAuth<AV>>
929
+
>,
930
+
) {
931
+
const nsid = 'app.rocksky.playlist.insertFiles' // @ts-ignore
932
+
return this._server.xrpc.method(nsid, cfg)
933
+
}
934
+
935
+
removePlaylist<AV extends AuthVerifier>(
936
+
cfg: ConfigOf<
937
+
AV,
938
+
AppRockskyPlaylistRemovePlaylist.Handler<ExtractAuth<AV>>,
939
+
AppRockskyPlaylistRemovePlaylist.HandlerReqCtx<ExtractAuth<AV>>
940
+
>,
941
+
) {
942
+
const nsid = 'app.rocksky.playlist.removePlaylist' // @ts-ignore
943
+
return this._server.xrpc.method(nsid, cfg)
944
+
}
945
+
946
+
removeTrack<AV extends AuthVerifier>(
947
+
cfg: ConfigOf<
948
+
AV,
949
+
AppRockskyPlaylistRemoveTrack.Handler<ExtractAuth<AV>>,
950
+
AppRockskyPlaylistRemoveTrack.HandlerReqCtx<ExtractAuth<AV>>
951
+
>,
952
+
) {
953
+
const nsid = 'app.rocksky.playlist.removeTrack' // @ts-ignore
954
+
return this._server.xrpc.method(nsid, cfg)
955
+
}
956
+
957
+
startPlaylist<AV extends AuthVerifier>(
958
+
cfg: ConfigOf<
959
+
AV,
960
+
AppRockskyPlaylistStartPlaylist.Handler<ExtractAuth<AV>>,
961
+
AppRockskyPlaylistStartPlaylist.HandlerReqCtx<ExtractAuth<AV>>
962
+
>,
963
+
) {
964
+
const nsid = 'app.rocksky.playlist.startPlaylist' // @ts-ignore
965
+
return this._server.xrpc.method(nsid, cfg)
966
+
}
967
+
}
968
+
969
+
export class AppRockskyScrobbleNS {
970
+
_server: Server
971
+
972
+
constructor(server: Server) {
973
+
this._server = server
974
+
}
975
+
976
+
createScrobble<AV extends AuthVerifier>(
977
+
cfg: ConfigOf<
978
+
AV,
979
+
AppRockskyScrobbleCreateScrobble.Handler<ExtractAuth<AV>>,
980
+
AppRockskyScrobbleCreateScrobble.HandlerReqCtx<ExtractAuth<AV>>
981
+
>,
982
+
) {
983
+
const nsid = 'app.rocksky.scrobble.createScrobble' // @ts-ignore
984
+
return this._server.xrpc.method(nsid, cfg)
985
+
}
986
+
987
+
getScrobble<AV extends AuthVerifier>(
988
+
cfg: ConfigOf<
989
+
AV,
990
+
AppRockskyScrobbleGetScrobble.Handler<ExtractAuth<AV>>,
991
+
AppRockskyScrobbleGetScrobble.HandlerReqCtx<ExtractAuth<AV>>
992
+
>,
993
+
) {
994
+
const nsid = 'app.rocksky.scrobble.getScrobble' // @ts-ignore
995
+
return this._server.xrpc.method(nsid, cfg)
996
+
}
997
+
998
+
getScrobbles<AV extends AuthVerifier>(
999
+
cfg: ConfigOf<
1000
+
AV,
1001
+
AppRockskyScrobbleGetScrobbles.Handler<ExtractAuth<AV>>,
1002
+
AppRockskyScrobbleGetScrobbles.HandlerReqCtx<ExtractAuth<AV>>
1003
+
>,
1004
+
) {
1005
+
const nsid = 'app.rocksky.scrobble.getScrobbles' // @ts-ignore
1006
+
return this._server.xrpc.method(nsid, cfg)
1007
+
}
1008
+
}
1009
+
1010
+
export class AppRockskyShoutNS {
1011
+
_server: Server
1012
+
1013
+
constructor(server: Server) {
1014
+
this._server = server
1015
+
}
1016
+
1017
+
createShout<AV extends AuthVerifier>(
1018
+
cfg: ConfigOf<
1019
+
AV,
1020
+
AppRockskyShoutCreateShout.Handler<ExtractAuth<AV>>,
1021
+
AppRockskyShoutCreateShout.HandlerReqCtx<ExtractAuth<AV>>
1022
+
>,
1023
+
) {
1024
+
const nsid = 'app.rocksky.shout.createShout' // @ts-ignore
1025
+
return this._server.xrpc.method(nsid, cfg)
1026
+
}
1027
+
1028
+
getAlbumShouts<AV extends AuthVerifier>(
1029
+
cfg: ConfigOf<
1030
+
AV,
1031
+
AppRockskyShoutGetAlbumShouts.Handler<ExtractAuth<AV>>,
1032
+
AppRockskyShoutGetAlbumShouts.HandlerReqCtx<ExtractAuth<AV>>
1033
+
>,
1034
+
) {
1035
+
const nsid = 'app.rocksky.shout.getAlbumShouts' // @ts-ignore
1036
+
return this._server.xrpc.method(nsid, cfg)
1037
+
}
1038
+
1039
+
getArtistShouts<AV extends AuthVerifier>(
1040
+
cfg: ConfigOf<
1041
+
AV,
1042
+
AppRockskyShoutGetArtistShouts.Handler<ExtractAuth<AV>>,
1043
+
AppRockskyShoutGetArtistShouts.HandlerReqCtx<ExtractAuth<AV>>
1044
+
>,
1045
+
) {
1046
+
const nsid = 'app.rocksky.shout.getArtistShouts' // @ts-ignore
1047
+
return this._server.xrpc.method(nsid, cfg)
1048
+
}
1049
+
1050
+
getProfileShouts<AV extends AuthVerifier>(
1051
+
cfg: ConfigOf<
1052
+
AV,
1053
+
AppRockskyShoutGetProfileShouts.Handler<ExtractAuth<AV>>,
1054
+
AppRockskyShoutGetProfileShouts.HandlerReqCtx<ExtractAuth<AV>>
1055
+
>,
1056
+
) {
1057
+
const nsid = 'app.rocksky.shout.getProfileShouts' // @ts-ignore
1058
+
return this._server.xrpc.method(nsid, cfg)
1059
+
}
1060
+
1061
+
getShoutReplies<AV extends AuthVerifier>(
1062
+
cfg: ConfigOf<
1063
+
AV,
1064
+
AppRockskyShoutGetShoutReplies.Handler<ExtractAuth<AV>>,
1065
+
AppRockskyShoutGetShoutReplies.HandlerReqCtx<ExtractAuth<AV>>
1066
+
>,
1067
+
) {
1068
+
const nsid = 'app.rocksky.shout.getShoutReplies' // @ts-ignore
1069
+
return this._server.xrpc.method(nsid, cfg)
1070
+
}
1071
+
1072
+
getTrackShouts<AV extends AuthVerifier>(
1073
+
cfg: ConfigOf<
1074
+
AV,
1075
+
AppRockskyShoutGetTrackShouts.Handler<ExtractAuth<AV>>,
1076
+
AppRockskyShoutGetTrackShouts.HandlerReqCtx<ExtractAuth<AV>>
1077
+
>,
1078
+
) {
1079
+
const nsid = 'app.rocksky.shout.getTrackShouts' // @ts-ignore
1080
+
return this._server.xrpc.method(nsid, cfg)
1081
+
}
1082
+
1083
+
removeShout<AV extends AuthVerifier>(
1084
+
cfg: ConfigOf<
1085
+
AV,
1086
+
AppRockskyShoutRemoveShout.Handler<ExtractAuth<AV>>,
1087
+
AppRockskyShoutRemoveShout.HandlerReqCtx<ExtractAuth<AV>>
1088
+
>,
1089
+
) {
1090
+
const nsid = 'app.rocksky.shout.removeShout' // @ts-ignore
1091
+
return this._server.xrpc.method(nsid, cfg)
1092
+
}
1093
+
1094
+
replyShout<AV extends AuthVerifier>(
1095
+
cfg: ConfigOf<
1096
+
AV,
1097
+
AppRockskyShoutReplyShout.Handler<ExtractAuth<AV>>,
1098
+
AppRockskyShoutReplyShout.HandlerReqCtx<ExtractAuth<AV>>
1099
+
>,
1100
+
) {
1101
+
const nsid = 'app.rocksky.shout.replyShout' // @ts-ignore
1102
+
return this._server.xrpc.method(nsid, cfg)
1103
+
}
1104
+
1105
+
reportShout<AV extends AuthVerifier>(
1106
+
cfg: ConfigOf<
1107
+
AV,
1108
+
AppRockskyShoutReportShout.Handler<ExtractAuth<AV>>,
1109
+
AppRockskyShoutReportShout.HandlerReqCtx<ExtractAuth<AV>>
1110
+
>,
1111
+
) {
1112
+
const nsid = 'app.rocksky.shout.reportShout' // @ts-ignore
1113
+
return this._server.xrpc.method(nsid, cfg)
1114
+
}
1115
+
}
1116
+
1117
+
export class AppRockskySongNS {
1118
+
_server: Server
1119
+
1120
+
constructor(server: Server) {
1121
+
this._server = server
1122
+
}
1123
+
1124
+
createSong<AV extends AuthVerifier>(
1125
+
cfg: ConfigOf<
1126
+
AV,
1127
+
AppRockskySongCreateSong.Handler<ExtractAuth<AV>>,
1128
+
AppRockskySongCreateSong.HandlerReqCtx<ExtractAuth<AV>>
1129
+
>,
1130
+
) {
1131
+
const nsid = 'app.rocksky.song.createSong' // @ts-ignore
1132
+
return this._server.xrpc.method(nsid, cfg)
1133
+
}
1134
+
1135
+
getSong<AV extends AuthVerifier>(
1136
+
cfg: ConfigOf<
1137
+
AV,
1138
+
AppRockskySongGetSong.Handler<ExtractAuth<AV>>,
1139
+
AppRockskySongGetSong.HandlerReqCtx<ExtractAuth<AV>>
1140
+
>,
1141
+
) {
1142
+
const nsid = 'app.rocksky.song.getSong' // @ts-ignore
1143
+
return this._server.xrpc.method(nsid, cfg)
1144
+
}
1145
+
1146
+
getSongs<AV extends AuthVerifier>(
1147
+
cfg: ConfigOf<
1148
+
AV,
1149
+
AppRockskySongGetSongs.Handler<ExtractAuth<AV>>,
1150
+
AppRockskySongGetSongs.HandlerReqCtx<ExtractAuth<AV>>
1151
+
>,
1152
+
) {
1153
+
const nsid = 'app.rocksky.song.getSongs' // @ts-ignore
1154
+
return this._server.xrpc.method(nsid, cfg)
1155
+
}
1156
+
}
1157
+
1158
+
export class AppRockskySpotifyNS {
1159
+
_server: Server
1160
+
1161
+
constructor(server: Server) {
1162
+
this._server = server
1163
+
}
1164
+
1165
+
getCurrentlyPlaying<AV extends AuthVerifier>(
1166
+
cfg: ConfigOf<
1167
+
AV,
1168
+
AppRockskySpotifyGetCurrentlyPlaying.Handler<ExtractAuth<AV>>,
1169
+
AppRockskySpotifyGetCurrentlyPlaying.HandlerReqCtx<ExtractAuth<AV>>
1170
+
>,
1171
+
) {
1172
+
const nsid = 'app.rocksky.spotify.getCurrentlyPlaying' // @ts-ignore
1173
+
return this._server.xrpc.method(nsid, cfg)
1174
+
}
1175
+
1176
+
next<AV extends AuthVerifier>(
1177
+
cfg: ConfigOf<
1178
+
AV,
1179
+
AppRockskySpotifyNext.Handler<ExtractAuth<AV>>,
1180
+
AppRockskySpotifyNext.HandlerReqCtx<ExtractAuth<AV>>
1181
+
>,
1182
+
) {
1183
+
const nsid = 'app.rocksky.spotify.next' // @ts-ignore
1184
+
return this._server.xrpc.method(nsid, cfg)
1185
+
}
1186
+
1187
+
pause<AV extends AuthVerifier>(
1188
+
cfg: ConfigOf<
1189
+
AV,
1190
+
AppRockskySpotifyPause.Handler<ExtractAuth<AV>>,
1191
+
AppRockskySpotifyPause.HandlerReqCtx<ExtractAuth<AV>>
1192
+
>,
1193
+
) {
1194
+
const nsid = 'app.rocksky.spotify.pause' // @ts-ignore
1195
+
return this._server.xrpc.method(nsid, cfg)
1196
+
}
1197
+
1198
+
play<AV extends AuthVerifier>(
1199
+
cfg: ConfigOf<
1200
+
AV,
1201
+
AppRockskySpotifyPlay.Handler<ExtractAuth<AV>>,
1202
+
AppRockskySpotifyPlay.HandlerReqCtx<ExtractAuth<AV>>
1203
+
>,
1204
+
) {
1205
+
const nsid = 'app.rocksky.spotify.play' // @ts-ignore
1206
+
return this._server.xrpc.method(nsid, cfg)
1207
+
}
1208
+
1209
+
previous<AV extends AuthVerifier>(
1210
+
cfg: ConfigOf<
1211
+
AV,
1212
+
AppRockskySpotifyPrevious.Handler<ExtractAuth<AV>>,
1213
+
AppRockskySpotifyPrevious.HandlerReqCtx<ExtractAuth<AV>>
1214
+
>,
1215
+
) {
1216
+
const nsid = 'app.rocksky.spotify.previous' // @ts-ignore
1217
+
return this._server.xrpc.method(nsid, cfg)
1218
+
}
1219
+
1220
+
seek<AV extends AuthVerifier>(
1221
+
cfg: ConfigOf<
1222
+
AV,
1223
+
AppRockskySpotifySeek.Handler<ExtractAuth<AV>>,
1224
+
AppRockskySpotifySeek.HandlerReqCtx<ExtractAuth<AV>>
1225
+
>,
1226
+
) {
1227
+
const nsid = 'app.rocksky.spotify.seek' // @ts-ignore
1228
+
return this._server.xrpc.method(nsid, cfg)
1229
+
}
1230
+
}
1231
+
1232
+
export class AppRockskyStatsNS {
1233
+
_server: Server
1234
+
1235
+
constructor(server: Server) {
1236
+
this._server = server
1237
+
}
1238
+
1239
+
getStats<AV extends AuthVerifier>(
1240
+
cfg: ConfigOf<
1241
+
AV,
1242
+
AppRockskyStatsGetStats.Handler<ExtractAuth<AV>>,
1243
+
AppRockskyStatsGetStats.HandlerReqCtx<ExtractAuth<AV>>
1244
+
>,
1245
+
) {
1246
+
const nsid = 'app.rocksky.stats.getStats' // @ts-ignore
1247
+
return this._server.xrpc.method(nsid, cfg)
1248
+
}
1249
+
}
1250
+
1251
+
export class AppBskyNS {
1252
+
_server: Server
1253
+
actor: AppBskyActorNS
1254
+
1255
+
constructor(server: Server) {
1256
+
this._server = server
1257
+
this.actor = new AppBskyActorNS(server)
1258
+
}
1259
+
}
1260
+
1261
+
export class AppBskyActorNS {
1262
+
_server: Server
1263
+
1264
+
constructor(server: Server) {
1265
+
this._server = server
1266
+
}
1267
+
}
1268
+
1269
+
export class ComNS {
1270
+
_server: Server
1271
+
atproto: ComAtprotoNS
1272
+
1273
+
constructor(server: Server) {
1274
+
this._server = server
1275
+
this.atproto = new ComAtprotoNS(server)
1276
+
}
1277
+
}
1278
+
1279
+
export class ComAtprotoNS {
1280
+
_server: Server
1281
+
repo: ComAtprotoRepoNS
1282
+
1283
+
constructor(server: Server) {
1284
+
this._server = server
1285
+
this.repo = new ComAtprotoRepoNS(server)
1286
+
}
1287
+
}
1288
+
1289
+
export class ComAtprotoRepoNS {
1290
+
_server: Server
1291
+
1292
+
constructor(server: Server) {
1293
+
this._server = server
1294
+
}
1295
+
}
1296
+
1297
+
type SharedRateLimitOpts<T> = {
1298
+
name: string
1299
+
calcKey?: (ctx: T) => string | null
1300
+
calcPoints?: (ctx: T) => number
1301
+
}
1302
+
type RouteRateLimitOpts<T> = {
1303
+
durationMs: number
1304
+
points: number
1305
+
calcKey?: (ctx: T) => string | null
1306
+
calcPoints?: (ctx: T) => number
1307
+
}
1308
+
type HandlerOpts = { blobLimit?: number }
1309
+
type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
1310
+
type ConfigOf<Auth, Handler, ReqCtx> =
1311
+
| Handler
1312
+
| {
1313
+
auth?: Auth
1314
+
opts?: HandlerOpts
1315
+
rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
1316
+
handler: Handler
1317
+
}
1318
+
type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
1319
+
Awaited<ReturnType<AV>>,
1320
+
{ credentials: unknown }
1321
+
>
+5453
apps/cli/src/lexicon/lexicons.ts
+5453
apps/cli/src/lexicon/lexicons.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { LexiconDoc, Lexicons } from '@atproto/lexicon'
5
+
6
+
export const schemaDict = {
7
+
AppRockskyActorDefs: {
8
+
lexicon: 1,
9
+
id: 'app.rocksky.actor.defs',
10
+
defs: {
11
+
profileViewDetailed: {
12
+
type: 'object',
13
+
properties: {
14
+
id: {
15
+
type: 'string',
16
+
description: 'The unique identifier of the actor.',
17
+
},
18
+
did: {
19
+
type: 'string',
20
+
description: 'The DID of the actor.',
21
+
},
22
+
handle: {
23
+
type: 'string',
24
+
description: 'The handle of the actor.',
25
+
},
26
+
displayName: {
27
+
type: 'string',
28
+
description: 'The display name of the actor.',
29
+
},
30
+
avatar: {
31
+
type: 'string',
32
+
description: "The URL of the actor's avatar image.",
33
+
format: 'uri',
34
+
},
35
+
createdAt: {
36
+
type: 'string',
37
+
description: 'The date and time when the actor was created.',
38
+
format: 'datetime',
39
+
},
40
+
updatedAt: {
41
+
type: 'string',
42
+
description: 'The date and time when the actor was last updated.',
43
+
format: 'datetime',
44
+
},
45
+
},
46
+
},
47
+
profileViewBasic: {
48
+
type: 'object',
49
+
properties: {
50
+
id: {
51
+
type: 'string',
52
+
description: 'The unique identifier of the actor.',
53
+
},
54
+
did: {
55
+
type: 'string',
56
+
description: 'The DID of the actor.',
57
+
},
58
+
handle: {
59
+
type: 'string',
60
+
description: 'The handle of the actor.',
61
+
},
62
+
displayName: {
63
+
type: 'string',
64
+
description: 'The display name of the actor.',
65
+
},
66
+
avatar: {
67
+
type: 'string',
68
+
description: "The URL of the actor's avatar image.",
69
+
format: 'uri',
70
+
},
71
+
createdAt: {
72
+
type: 'string',
73
+
description: 'The date and time when the actor was created.',
74
+
format: 'datetime',
75
+
},
76
+
updatedAt: {
77
+
type: 'string',
78
+
description: 'The date and time when the actor was last updated.',
79
+
format: 'datetime',
80
+
},
81
+
},
82
+
},
83
+
neighbourViewBasic: {
84
+
type: 'object',
85
+
properties: {
86
+
userId: {
87
+
type: 'string',
88
+
},
89
+
did: {
90
+
type: 'string',
91
+
},
92
+
handle: {
93
+
type: 'string',
94
+
},
95
+
displayName: {
96
+
type: 'string',
97
+
},
98
+
avatar: {
99
+
type: 'string',
100
+
description: "The URL of the actor's avatar image.",
101
+
format: 'uri',
102
+
},
103
+
sharedArtistsCount: {
104
+
type: 'integer',
105
+
description: 'The number of artists shared with the actor.',
106
+
},
107
+
similarityScore: {
108
+
type: 'integer',
109
+
description: 'The similarity score with the actor.',
110
+
},
111
+
topSharedArtistNames: {
112
+
type: 'array',
113
+
description: 'The top shared artist names with the actor.',
114
+
items: {
115
+
type: 'string',
116
+
},
117
+
},
118
+
topSharedArtistsDetails: {
119
+
type: 'array',
120
+
description: 'The top shared artist details with the actor.',
121
+
items: {
122
+
type: 'ref',
123
+
ref: 'lex:app.rocksky.artist.defs#artistViewBasic',
124
+
},
125
+
},
126
+
},
127
+
},
128
+
compatibilityViewBasic: {
129
+
type: 'object',
130
+
properties: {
131
+
compatibilityLevel: {
132
+
type: 'integer',
133
+
},
134
+
compatibilityPercentage: {
135
+
type: 'integer',
136
+
},
137
+
sharedArtists: {
138
+
type: 'integer',
139
+
},
140
+
topSharedArtistNames: {
141
+
type: 'array',
142
+
items: {
143
+
type: 'string',
144
+
},
145
+
},
146
+
topSharedDetailedArtists: {
147
+
type: 'array',
148
+
items: {
149
+
type: 'ref',
150
+
ref: 'lex:app.rocksky.actor.defs#artistViewBasic',
151
+
},
152
+
},
153
+
user1ArtistCount: {
154
+
type: 'integer',
155
+
},
156
+
user2ArtistCount: {
157
+
type: 'integer',
158
+
},
159
+
},
160
+
},
161
+
artistViewBasic: {
162
+
type: 'object',
163
+
properties: {
164
+
id: {
165
+
type: 'string',
166
+
},
167
+
name: {
168
+
type: 'string',
169
+
},
170
+
picture: {
171
+
type: 'string',
172
+
format: 'uri',
173
+
},
174
+
uri: {
175
+
type: 'string',
176
+
format: 'at-uri',
177
+
},
178
+
user1Rank: {
179
+
type: 'integer',
180
+
},
181
+
user2Rank: {
182
+
type: 'integer',
183
+
},
184
+
weight: {
185
+
type: 'integer',
186
+
},
187
+
},
188
+
},
189
+
},
190
+
},
191
+
AppRockskyActorGetActorAlbums: {
192
+
lexicon: 1,
193
+
id: 'app.rocksky.actor.getActorAlbums',
194
+
defs: {
195
+
main: {
196
+
type: 'query',
197
+
description: 'Get albums for an actor',
198
+
parameters: {
199
+
type: 'params',
200
+
required: ['did'],
201
+
properties: {
202
+
did: {
203
+
type: 'string',
204
+
description: 'The DID or handle of the actor',
205
+
format: 'at-identifier',
206
+
},
207
+
limit: {
208
+
type: 'integer',
209
+
description: 'The maximum number of albums to return',
210
+
minimum: 1,
211
+
},
212
+
offset: {
213
+
type: 'integer',
214
+
description: 'The offset for pagination',
215
+
minimum: 0,
216
+
},
217
+
startDate: {
218
+
type: 'string',
219
+
description:
220
+
'The start date to filter albums from (ISO 8601 format)',
221
+
format: 'datetime',
222
+
},
223
+
endDate: {
224
+
type: 'string',
225
+
description: 'The end date to filter albums to (ISO 8601 format)',
226
+
format: 'datetime',
227
+
},
228
+
},
229
+
},
230
+
output: {
231
+
encoding: 'application/json',
232
+
schema: {
233
+
type: 'object',
234
+
properties: {
235
+
albums: {
236
+
type: 'array',
237
+
items: {
238
+
type: 'ref',
239
+
ref: 'lex:app.rocksky.album.defs#albumViewBasic',
240
+
},
241
+
},
242
+
},
243
+
},
244
+
},
245
+
},
246
+
},
247
+
},
248
+
AppRockskyActorGetActorArtists: {
249
+
lexicon: 1,
250
+
id: 'app.rocksky.actor.getActorArtists',
251
+
defs: {
252
+
main: {
253
+
type: 'query',
254
+
description: 'Get artists for an actor',
255
+
parameters: {
256
+
type: 'params',
257
+
required: ['did'],
258
+
properties: {
259
+
did: {
260
+
type: 'string',
261
+
description: 'The DID or handle of the actor',
262
+
format: 'at-identifier',
263
+
},
264
+
limit: {
265
+
type: 'integer',
266
+
description: 'The maximum number of albums to return',
267
+
minimum: 1,
268
+
},
269
+
offset: {
270
+
type: 'integer',
271
+
description: 'The offset for pagination',
272
+
minimum: 0,
273
+
},
274
+
startDate: {
275
+
type: 'string',
276
+
description:
277
+
'The start date to filter albums from (ISO 8601 format)',
278
+
format: 'datetime',
279
+
},
280
+
endDate: {
281
+
type: 'string',
282
+
description: 'The end date to filter albums to (ISO 8601 format)',
283
+
format: 'datetime',
284
+
},
285
+
},
286
+
},
287
+
output: {
288
+
encoding: 'application/json',
289
+
schema: {
290
+
type: 'object',
291
+
properties: {
292
+
artists: {
293
+
type: 'array',
294
+
items: {
295
+
type: 'ref',
296
+
ref: 'lex:app.rocksky.artist.defs#artistViewBasic',
297
+
},
298
+
},
299
+
},
300
+
},
301
+
},
302
+
},
303
+
},
304
+
},
305
+
AppRockskyActorGetActorCompatibility: {
306
+
lexicon: 1,
307
+
id: 'app.rocksky.actor.getActorCompatibility',
308
+
defs: {
309
+
main: {
310
+
type: 'query',
311
+
description: 'Get compatibility for an actor',
312
+
parameters: {
313
+
type: 'params',
314
+
required: ['did'],
315
+
properties: {
316
+
did: {
317
+
type: 'string',
318
+
description: 'DID or handle to get compatibility for',
319
+
format: 'at-identifier',
320
+
},
321
+
},
322
+
},
323
+
output: {
324
+
encoding: 'application/json',
325
+
schema: {
326
+
type: 'object',
327
+
properties: {
328
+
compatibility: {
329
+
type: 'ref',
330
+
ref: 'lex:app.rocksky.actor.defs#compatibilityViewBasic',
331
+
},
332
+
},
333
+
},
334
+
},
335
+
},
336
+
},
337
+
},
338
+
AppRockskyActorGetActorLovedSongs: {
339
+
lexicon: 1,
340
+
id: 'app.rocksky.actor.getActorLovedSongs',
341
+
defs: {
342
+
main: {
343
+
type: 'query',
344
+
description: 'Get loved songs for an actor',
345
+
parameters: {
346
+
type: 'params',
347
+
required: ['did'],
348
+
properties: {
349
+
did: {
350
+
type: 'string',
351
+
description: 'The DID or handle of the actor',
352
+
format: 'at-identifier',
353
+
},
354
+
limit: {
355
+
type: 'integer',
356
+
description: 'The maximum number of albums to return',
357
+
minimum: 1,
358
+
},
359
+
offset: {
360
+
type: 'integer',
361
+
description: 'The offset for pagination',
362
+
minimum: 0,
363
+
},
364
+
},
365
+
},
366
+
output: {
367
+
encoding: 'application/json',
368
+
schema: {
369
+
type: 'object',
370
+
properties: {
371
+
tracks: {
372
+
type: 'array',
373
+
items: {
374
+
type: 'ref',
375
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
376
+
},
377
+
},
378
+
},
379
+
},
380
+
},
381
+
},
382
+
},
383
+
},
384
+
AppRockskyActorGetActorNeighbours: {
385
+
lexicon: 1,
386
+
id: 'app.rocksky.actor.getActorNeighbours',
387
+
defs: {
388
+
main: {
389
+
type: 'query',
390
+
description: 'Get neighbours for an actor',
391
+
parameters: {
392
+
type: 'params',
393
+
required: ['did'],
394
+
properties: {
395
+
did: {
396
+
type: 'string',
397
+
description: 'The DID or handle of the actor',
398
+
format: 'at-identifier',
399
+
},
400
+
},
401
+
},
402
+
output: {
403
+
encoding: 'application/json',
404
+
schema: {
405
+
type: 'object',
406
+
properties: {
407
+
neighbours: {
408
+
type: 'array',
409
+
items: {
410
+
type: 'ref',
411
+
ref: 'lex:app.rocksky.actor.defs#neighbourViewBasic',
412
+
},
413
+
},
414
+
},
415
+
},
416
+
},
417
+
},
418
+
},
419
+
},
420
+
AppRockskyActorGetActorPlaylists: {
421
+
lexicon: 1,
422
+
id: 'app.rocksky.actor.getActorPlaylists',
423
+
defs: {
424
+
main: {
425
+
type: 'query',
426
+
description: 'Get playlists for an actor',
427
+
parameters: {
428
+
type: 'params',
429
+
required: ['did'],
430
+
properties: {
431
+
did: {
432
+
type: 'string',
433
+
description: 'The DID or handle of the actor',
434
+
format: 'at-identifier',
435
+
},
436
+
limit: {
437
+
type: 'integer',
438
+
description: 'The maximum number of albums to return',
439
+
minimum: 1,
440
+
},
441
+
offset: {
442
+
type: 'integer',
443
+
description: 'The offset for pagination',
444
+
minimum: 0,
445
+
},
446
+
},
447
+
},
448
+
output: {
449
+
encoding: 'application/json',
450
+
schema: {
451
+
type: 'object',
452
+
properties: {
453
+
playlists: {
454
+
type: 'array',
455
+
items: {
456
+
type: 'ref',
457
+
ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic',
458
+
},
459
+
},
460
+
},
461
+
},
462
+
},
463
+
},
464
+
},
465
+
},
466
+
AppRockskyActorGetActorScrobbles: {
467
+
lexicon: 1,
468
+
id: 'app.rocksky.actor.getActorScrobbles',
469
+
defs: {
470
+
main: {
471
+
type: 'query',
472
+
description: 'Get scrobbles for an actor',
473
+
parameters: {
474
+
type: 'params',
475
+
required: ['did'],
476
+
properties: {
477
+
did: {
478
+
type: 'string',
479
+
description: 'The DID or handle of the actor',
480
+
format: 'at-identifier',
481
+
},
482
+
limit: {
483
+
type: 'integer',
484
+
description: 'The maximum number of albums to return',
485
+
minimum: 1,
486
+
},
487
+
offset: {
488
+
type: 'integer',
489
+
description: 'The offset for pagination',
490
+
minimum: 0,
491
+
},
492
+
},
493
+
},
494
+
output: {
495
+
encoding: 'application/json',
496
+
schema: {
497
+
type: 'object',
498
+
properties: {
499
+
scrobbles: {
500
+
type: 'array',
501
+
items: {
502
+
type: 'ref',
503
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
504
+
},
505
+
},
506
+
},
507
+
},
508
+
},
509
+
},
510
+
},
511
+
},
512
+
AppRockskyActorGetActorSongs: {
513
+
lexicon: 1,
514
+
id: 'app.rocksky.actor.getActorSongs',
515
+
defs: {
516
+
main: {
517
+
type: 'query',
518
+
description: 'Get songs for an actor',
519
+
parameters: {
520
+
type: 'params',
521
+
required: ['did'],
522
+
properties: {
523
+
did: {
524
+
type: 'string',
525
+
description: 'The DID or handle of the actor',
526
+
format: 'at-identifier',
527
+
},
528
+
limit: {
529
+
type: 'integer',
530
+
description: 'The maximum number of albums to return',
531
+
minimum: 1,
532
+
},
533
+
offset: {
534
+
type: 'integer',
535
+
description: 'The offset for pagination',
536
+
minimum: 0,
537
+
},
538
+
startDate: {
539
+
type: 'string',
540
+
description:
541
+
'The start date to filter albums from (ISO 8601 format)',
542
+
format: 'datetime',
543
+
},
544
+
endDate: {
545
+
type: 'string',
546
+
description: 'The end date to filter albums to (ISO 8601 format)',
547
+
format: 'datetime',
548
+
},
549
+
},
550
+
},
551
+
output: {
552
+
encoding: 'application/json',
553
+
schema: {
554
+
type: 'object',
555
+
properties: {
556
+
songs: {
557
+
type: 'array',
558
+
items: {
559
+
type: 'ref',
560
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
561
+
},
562
+
},
563
+
},
564
+
},
565
+
},
566
+
},
567
+
},
568
+
},
569
+
AppRockskyActorGetProfile: {
570
+
lexicon: 1,
571
+
id: 'app.rocksky.actor.getProfile',
572
+
defs: {
573
+
main: {
574
+
type: 'query',
575
+
description: 'Get the profile of an actor',
576
+
parameters: {
577
+
type: 'params',
578
+
properties: {
579
+
did: {
580
+
type: 'string',
581
+
description: 'The DID or handle of the actor',
582
+
format: 'at-identifier',
583
+
},
584
+
},
585
+
},
586
+
output: {
587
+
encoding: 'application/json',
588
+
schema: {
589
+
type: 'ref',
590
+
ref: 'lex:app.rocksky.actor.defs#profileViewDetailed',
591
+
},
592
+
},
593
+
},
594
+
},
595
+
},
596
+
AppBskyActorProfile: {
597
+
lexicon: 1,
598
+
id: 'app.bsky.actor.profile',
599
+
defs: {
600
+
main: {
601
+
type: 'record',
602
+
description: 'A declaration of a Bluesky account profile.',
603
+
key: 'literal:self',
604
+
record: {
605
+
type: 'object',
606
+
properties: {
607
+
displayName: {
608
+
type: 'string',
609
+
maxGraphemes: 64,
610
+
maxLength: 640,
611
+
},
612
+
description: {
613
+
type: 'string',
614
+
description: 'Free-form profile description text.',
615
+
maxGraphemes: 256,
616
+
maxLength: 2560,
617
+
},
618
+
avatar: {
619
+
type: 'blob',
620
+
description:
621
+
"Small image to be displayed next to posts from account. AKA, 'profile picture'",
622
+
accept: ['image/png', 'image/jpeg'],
623
+
maxSize: 1000000,
624
+
},
625
+
banner: {
626
+
type: 'blob',
627
+
description:
628
+
'Larger horizontal image to display behind profile view.',
629
+
accept: ['image/png', 'image/jpeg'],
630
+
maxSize: 10000000,
631
+
},
632
+
labels: {
633
+
type: 'union',
634
+
description:
635
+
'Self-label values, specific to the Bluesky application, on the overall account.',
636
+
refs: ['lex:com.atproto.label.defs#selfLabels'],
637
+
},
638
+
joinedViaStarterPack: {
639
+
type: 'ref',
640
+
ref: 'lex:com.atproto.repo.strongRef',
641
+
},
642
+
createdAt: {
643
+
type: 'string',
644
+
format: 'datetime',
645
+
},
646
+
},
647
+
},
648
+
},
649
+
},
650
+
},
651
+
AppRockskyAlbum: {
652
+
lexicon: 1,
653
+
id: 'app.rocksky.album',
654
+
defs: {
655
+
main: {
656
+
type: 'record',
657
+
description: 'A declaration of an album.',
658
+
key: 'tid',
659
+
record: {
660
+
type: 'object',
661
+
required: ['title', 'artist', 'createdAt'],
662
+
properties: {
663
+
title: {
664
+
type: 'string',
665
+
description: 'The title of the album.',
666
+
minLength: 1,
667
+
maxLength: 512,
668
+
},
669
+
artist: {
670
+
type: 'string',
671
+
description: 'The artist of the album.',
672
+
minLength: 1,
673
+
maxLength: 256,
674
+
},
675
+
duration: {
676
+
type: 'integer',
677
+
description: 'The duration of the album in seconds.',
678
+
},
679
+
releaseDate: {
680
+
type: 'string',
681
+
description: 'The release date of the album.',
682
+
format: 'datetime',
683
+
},
684
+
year: {
685
+
type: 'integer',
686
+
description: 'The year the album was released.',
687
+
},
688
+
genre: {
689
+
type: 'string',
690
+
description: 'The genre of the album.',
691
+
maxLength: 256,
692
+
},
693
+
albumArt: {
694
+
type: 'blob',
695
+
description: 'The album art of the album.',
696
+
accept: ['image/png', 'image/jpeg'],
697
+
maxSize: 2000000,
698
+
},
699
+
albumArtUrl: {
700
+
type: 'string',
701
+
description: 'The URL of the album art of the album.',
702
+
format: 'uri',
703
+
},
704
+
tags: {
705
+
type: 'array',
706
+
description: 'The tags of the album.',
707
+
items: {
708
+
type: 'string',
709
+
minLength: 1,
710
+
maxLength: 256,
711
+
},
712
+
},
713
+
youtubeLink: {
714
+
type: 'string',
715
+
description: 'The YouTube link of the album.',
716
+
format: 'uri',
717
+
},
718
+
spotifyLink: {
719
+
type: 'string',
720
+
description: 'The Spotify link of the album.',
721
+
format: 'uri',
722
+
},
723
+
tidalLink: {
724
+
type: 'string',
725
+
description: 'The tidal link of the album.',
726
+
format: 'uri',
727
+
},
728
+
appleMusicLink: {
729
+
type: 'string',
730
+
description: 'The Apple Music link of the album.',
731
+
format: 'uri',
732
+
},
733
+
createdAt: {
734
+
type: 'string',
735
+
description: 'The date and time when the album was created.',
736
+
format: 'datetime',
737
+
},
738
+
},
739
+
},
740
+
},
741
+
},
742
+
},
743
+
AppRockskyAlbumDefs: {
744
+
lexicon: 1,
745
+
id: 'app.rocksky.album.defs',
746
+
defs: {
747
+
albumViewBasic: {
748
+
type: 'object',
749
+
properties: {
750
+
id: {
751
+
type: 'string',
752
+
description: 'The unique identifier of the album.',
753
+
},
754
+
uri: {
755
+
type: 'string',
756
+
description: 'The URI of the album.',
757
+
format: 'at-uri',
758
+
},
759
+
title: {
760
+
type: 'string',
761
+
description: 'The title of the album.',
762
+
},
763
+
artist: {
764
+
type: 'string',
765
+
description: 'The artist of the album.',
766
+
},
767
+
artistUri: {
768
+
type: 'string',
769
+
description: "The URI of the album's artist.",
770
+
format: 'at-uri',
771
+
},
772
+
year: {
773
+
type: 'integer',
774
+
description: 'The year the album was released.',
775
+
},
776
+
albumArt: {
777
+
type: 'string',
778
+
description: 'The URL of the album art image.',
779
+
format: 'uri',
780
+
},
781
+
releaseDate: {
782
+
type: 'string',
783
+
description: 'The release date of the album.',
784
+
},
785
+
sha256: {
786
+
type: 'string',
787
+
description: 'The SHA256 hash of the album.',
788
+
},
789
+
playCount: {
790
+
type: 'integer',
791
+
description: 'The number of times the album has been played.',
792
+
minimum: 0,
793
+
},
794
+
uniqueListeners: {
795
+
type: 'integer',
796
+
description:
797
+
'The number of unique listeners who have played the album.',
798
+
minimum: 0,
799
+
},
800
+
},
801
+
},
802
+
albumViewDetailed: {
803
+
type: 'object',
804
+
properties: {
805
+
id: {
806
+
type: 'string',
807
+
description: 'The unique identifier of the album.',
808
+
},
809
+
uri: {
810
+
type: 'string',
811
+
description: 'The URI of the album.',
812
+
format: 'at-uri',
813
+
},
814
+
title: {
815
+
type: 'string',
816
+
description: 'The title of the album.',
817
+
},
818
+
artist: {
819
+
type: 'string',
820
+
description: 'The artist of the album.',
821
+
},
822
+
artistUri: {
823
+
type: 'string',
824
+
description: "The URI of the album's artist.",
825
+
format: 'at-uri',
826
+
},
827
+
year: {
828
+
type: 'integer',
829
+
description: 'The year the album was released.',
830
+
},
831
+
albumArt: {
832
+
type: 'string',
833
+
description: 'The URL of the album art image.',
834
+
format: 'uri',
835
+
},
836
+
releaseDate: {
837
+
type: 'string',
838
+
description: 'The release date of the album.',
839
+
},
840
+
sha256: {
841
+
type: 'string',
842
+
description: 'The SHA256 hash of the album.',
843
+
},
844
+
playCount: {
845
+
type: 'integer',
846
+
description: 'The number of times the album has been played.',
847
+
minimum: 0,
848
+
},
849
+
uniqueListeners: {
850
+
type: 'integer',
851
+
description:
852
+
'The number of unique listeners who have played the album.',
853
+
minimum: 0,
854
+
},
855
+
tracks: {
856
+
type: 'array',
857
+
items: {
858
+
type: 'ref',
859
+
ref: 'lex:app.rocksky.song.defs.songViewBasic',
860
+
},
861
+
},
862
+
},
863
+
},
864
+
},
865
+
},
866
+
AppRockskyAlbumGetAlbum: {
867
+
lexicon: 1,
868
+
id: 'app.rocksky.album.getAlbum',
869
+
defs: {
870
+
main: {
871
+
type: 'query',
872
+
description: 'Get detailed album view',
873
+
parameters: {
874
+
type: 'params',
875
+
required: ['uri'],
876
+
properties: {
877
+
uri: {
878
+
type: 'string',
879
+
description: 'The URI of the album to retrieve.',
880
+
format: 'at-uri',
881
+
},
882
+
},
883
+
},
884
+
output: {
885
+
encoding: 'application/json',
886
+
schema: {
887
+
type: 'ref',
888
+
ref: 'lex:app.rocksky.album.defs#albumViewDetailed',
889
+
},
890
+
},
891
+
},
892
+
},
893
+
},
894
+
AppRockskyAlbumGetAlbums: {
895
+
lexicon: 1,
896
+
id: 'app.rocksky.album.getAlbums',
897
+
defs: {
898
+
main: {
899
+
type: 'query',
900
+
description: 'Get albums',
901
+
parameters: {
902
+
type: 'params',
903
+
properties: {
904
+
limit: {
905
+
type: 'integer',
906
+
description: 'The maximum number of albums to return',
907
+
minimum: 1,
908
+
},
909
+
offset: {
910
+
type: 'integer',
911
+
description: 'The offset for pagination',
912
+
minimum: 0,
913
+
},
914
+
},
915
+
},
916
+
output: {
917
+
encoding: 'application/json',
918
+
schema: {
919
+
type: 'object',
920
+
properties: {
921
+
albums: {
922
+
type: 'array',
923
+
items: {
924
+
type: 'ref',
925
+
ref: 'lex:app.rocksky.album.defs#albumViewBasic',
926
+
},
927
+
},
928
+
},
929
+
},
930
+
},
931
+
},
932
+
},
933
+
},
934
+
AppRockskyAlbumGetAlbumTracks: {
935
+
lexicon: 1,
936
+
id: 'app.rocksky.album.getAlbumTracks',
937
+
defs: {
938
+
main: {
939
+
type: 'query',
940
+
description: 'Get tracks for an album',
941
+
parameters: {
942
+
type: 'params',
943
+
required: ['uri'],
944
+
properties: {
945
+
uri: {
946
+
type: 'string',
947
+
description: 'The URI of the album to retrieve tracks from',
948
+
format: 'at-uri',
949
+
},
950
+
},
951
+
},
952
+
output: {
953
+
encoding: 'application/json',
954
+
schema: {
955
+
type: 'object',
956
+
properties: {
957
+
tracks: {
958
+
type: 'array',
959
+
items: {
960
+
type: 'ref',
961
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
962
+
},
963
+
},
964
+
},
965
+
},
966
+
},
967
+
},
968
+
},
969
+
},
970
+
AppRockskyApikeyCreateApikey: {
971
+
lexicon: 1,
972
+
id: 'app.rocksky.apikey.createApikey',
973
+
defs: {
974
+
main: {
975
+
type: 'procedure',
976
+
description: 'Create a new API key for the authenticated user',
977
+
input: {
978
+
encoding: 'application/json',
979
+
schema: {
980
+
type: 'object',
981
+
required: ['name'],
982
+
properties: {
983
+
name: {
984
+
type: 'string',
985
+
description: 'The name of the API key.',
986
+
},
987
+
description: {
988
+
type: 'string',
989
+
description: 'A description for the API key.',
990
+
},
991
+
},
992
+
},
993
+
},
994
+
output: {
995
+
encoding: 'application/json',
996
+
schema: {
997
+
type: 'ref',
998
+
ref: 'lex:app.rocksky.apikey.defs#apiKey',
999
+
},
1000
+
},
1001
+
},
1002
+
},
1003
+
},
1004
+
AppRockskyApikeyDefs: {
1005
+
lexicon: 1,
1006
+
id: 'app.rocksky.apikey.defs',
1007
+
defs: {
1008
+
apiKeyView: {
1009
+
type: 'object',
1010
+
properties: {
1011
+
id: {
1012
+
type: 'string',
1013
+
description: 'The unique identifier of the API key.',
1014
+
},
1015
+
name: {
1016
+
type: 'string',
1017
+
description: 'The name of the API key.',
1018
+
},
1019
+
description: {
1020
+
type: 'string',
1021
+
description: 'A description for the API key.',
1022
+
},
1023
+
createdAt: {
1024
+
type: 'string',
1025
+
description: 'The date and time when the API key was created.',
1026
+
format: 'datetime',
1027
+
},
1028
+
},
1029
+
},
1030
+
},
1031
+
},
1032
+
AppRockskyApikeysDefs: {
1033
+
lexicon: 1,
1034
+
id: 'app.rocksky.apikeys.defs',
1035
+
defs: {},
1036
+
},
1037
+
AppRockskyApikeyGetApikeys: {
1038
+
lexicon: 1,
1039
+
id: 'app.rocksky.apikey.getApikeys',
1040
+
defs: {
1041
+
main: {
1042
+
type: 'query',
1043
+
description: 'Get a list of API keys for the authenticated user',
1044
+
parameters: {
1045
+
type: 'params',
1046
+
properties: {
1047
+
offset: {
1048
+
type: 'integer',
1049
+
description:
1050
+
'The number of API keys to skip before starting to collect the result set.',
1051
+
},
1052
+
limit: {
1053
+
type: 'integer',
1054
+
description: 'The number of API keys to return per page.',
1055
+
},
1056
+
},
1057
+
},
1058
+
output: {
1059
+
encoding: 'application/json',
1060
+
schema: {
1061
+
type: 'object',
1062
+
properties: {
1063
+
apiKeys: {
1064
+
type: 'array',
1065
+
items: {
1066
+
type: 'ref',
1067
+
ref: 'lex:app.rocksky.apikey.defs#apikeyView',
1068
+
},
1069
+
},
1070
+
},
1071
+
},
1072
+
},
1073
+
},
1074
+
},
1075
+
},
1076
+
AppRockskyApikeyRemoveApikey: {
1077
+
lexicon: 1,
1078
+
id: 'app.rocksky.apikey.removeApikey',
1079
+
defs: {
1080
+
main: {
1081
+
type: 'procedure',
1082
+
description: 'Remove an API key for the authenticated user',
1083
+
parameters: {
1084
+
type: 'params',
1085
+
required: ['id'],
1086
+
properties: {
1087
+
id: {
1088
+
type: 'string',
1089
+
description: 'The ID of the API key to remove.',
1090
+
},
1091
+
},
1092
+
},
1093
+
output: {
1094
+
encoding: 'application/json',
1095
+
schema: {
1096
+
type: 'ref',
1097
+
ref: 'lex:app.rocksky.apikey.defs#apiKey',
1098
+
},
1099
+
},
1100
+
},
1101
+
},
1102
+
},
1103
+
AppRockskyApikeyUpdateApikey: {
1104
+
lexicon: 1,
1105
+
id: 'app.rocksky.apikey.updateApikey',
1106
+
defs: {
1107
+
main: {
1108
+
type: 'procedure',
1109
+
description: 'Update an existing API key for the authenticated user',
1110
+
input: {
1111
+
encoding: 'application/json',
1112
+
schema: {
1113
+
type: 'object',
1114
+
required: ['id', 'name'],
1115
+
properties: {
1116
+
id: {
1117
+
type: 'string',
1118
+
description: 'The ID of the API key to update.',
1119
+
},
1120
+
name: {
1121
+
type: 'string',
1122
+
description: 'The new name of the API key.',
1123
+
},
1124
+
description: {
1125
+
type: 'string',
1126
+
description: 'A new description for the API key.',
1127
+
},
1128
+
},
1129
+
},
1130
+
},
1131
+
output: {
1132
+
encoding: 'application/json',
1133
+
schema: {
1134
+
type: 'ref',
1135
+
ref: 'lex:app.rocksky.apikey.defs#apiKey',
1136
+
},
1137
+
},
1138
+
},
1139
+
},
1140
+
},
1141
+
AppRockskyArtist: {
1142
+
lexicon: 1,
1143
+
id: 'app.rocksky.artist',
1144
+
defs: {
1145
+
main: {
1146
+
type: 'record',
1147
+
description: 'A declaration of an artist.',
1148
+
key: 'tid',
1149
+
record: {
1150
+
type: 'object',
1151
+
required: ['name', 'createdAt'],
1152
+
properties: {
1153
+
name: {
1154
+
type: 'string',
1155
+
description: 'The name of the artist.',
1156
+
minLength: 1,
1157
+
maxLength: 512,
1158
+
},
1159
+
bio: {
1160
+
type: 'string',
1161
+
description: 'The biography of the artist.',
1162
+
maxLength: 1000,
1163
+
},
1164
+
picture: {
1165
+
type: 'blob',
1166
+
description: 'The picture of the artist.',
1167
+
accept: ['image/png', 'image/jpeg'],
1168
+
maxSize: 2000000,
1169
+
},
1170
+
pictureUrl: {
1171
+
type: 'string',
1172
+
description: 'The URL of the picture of the artist.',
1173
+
format: 'uri',
1174
+
},
1175
+
tags: {
1176
+
type: 'array',
1177
+
description: 'The tags of the artist.',
1178
+
items: {
1179
+
type: 'string',
1180
+
minLength: 1,
1181
+
maxLength: 256,
1182
+
},
1183
+
},
1184
+
born: {
1185
+
type: 'string',
1186
+
description: 'The birth date of the artist.',
1187
+
format: 'datetime',
1188
+
},
1189
+
died: {
1190
+
type: 'string',
1191
+
description: 'The death date of the artist.',
1192
+
format: 'datetime',
1193
+
},
1194
+
bornIn: {
1195
+
type: 'string',
1196
+
description: 'The birth place of the artist.',
1197
+
maxLength: 256,
1198
+
},
1199
+
createdAt: {
1200
+
type: 'string',
1201
+
description: 'The date when the artist was created.',
1202
+
format: 'datetime',
1203
+
},
1204
+
},
1205
+
},
1206
+
},
1207
+
},
1208
+
},
1209
+
AppRockskyArtistDefs: {
1210
+
lexicon: 1,
1211
+
id: 'app.rocksky.artist.defs',
1212
+
defs: {
1213
+
artistViewBasic: {
1214
+
type: 'object',
1215
+
properties: {
1216
+
id: {
1217
+
type: 'string',
1218
+
description: 'The unique identifier of the artist.',
1219
+
},
1220
+
uri: {
1221
+
type: 'string',
1222
+
description: 'The URI of the artist.',
1223
+
format: 'at-uri',
1224
+
},
1225
+
name: {
1226
+
type: 'string',
1227
+
description: 'The name of the artist.',
1228
+
},
1229
+
picture: {
1230
+
type: 'string',
1231
+
description: 'The picture of the artist.',
1232
+
},
1233
+
sha256: {
1234
+
type: 'string',
1235
+
description: 'The SHA256 hash of the artist.',
1236
+
},
1237
+
playCount: {
1238
+
type: 'integer',
1239
+
description: 'The number of times the artist has been played.',
1240
+
minimum: 0,
1241
+
},
1242
+
uniqueListeners: {
1243
+
type: 'integer',
1244
+
description:
1245
+
'The number of unique listeners who have played the artist.',
1246
+
minimum: 0,
1247
+
},
1248
+
},
1249
+
},
1250
+
artistViewDetailed: {
1251
+
type: 'object',
1252
+
properties: {
1253
+
id: {
1254
+
type: 'string',
1255
+
description: 'The unique identifier of the artist.',
1256
+
},
1257
+
uri: {
1258
+
type: 'string',
1259
+
description: 'The URI of the artist.',
1260
+
format: 'at-uri',
1261
+
},
1262
+
name: {
1263
+
type: 'string',
1264
+
description: 'The name of the artist.',
1265
+
},
1266
+
picture: {
1267
+
type: 'string',
1268
+
description: 'The picture of the artist.',
1269
+
},
1270
+
sha256: {
1271
+
type: 'string',
1272
+
description: 'The SHA256 hash of the artist.',
1273
+
},
1274
+
playCount: {
1275
+
type: 'integer',
1276
+
description: 'The number of times the artist has been played.',
1277
+
minimum: 0,
1278
+
},
1279
+
uniqueListeners: {
1280
+
type: 'integer',
1281
+
description:
1282
+
'The number of unique listeners who have played the artist.',
1283
+
minimum: 0,
1284
+
},
1285
+
},
1286
+
},
1287
+
songViewBasic: {
1288
+
type: 'object',
1289
+
properties: {
1290
+
uri: {
1291
+
type: 'string',
1292
+
description: 'The URI of the song.',
1293
+
format: 'at-uri',
1294
+
},
1295
+
title: {
1296
+
type: 'string',
1297
+
description: 'The title of the song.',
1298
+
},
1299
+
playCount: {
1300
+
type: 'integer',
1301
+
description: 'The number of times the song has been played.',
1302
+
minimum: 0,
1303
+
},
1304
+
},
1305
+
},
1306
+
listenerViewBasic: {
1307
+
type: 'object',
1308
+
properties: {
1309
+
id: {
1310
+
type: 'string',
1311
+
description: 'The unique identifier of the actor.',
1312
+
},
1313
+
did: {
1314
+
type: 'string',
1315
+
description: 'The DID of the listener.',
1316
+
},
1317
+
handle: {
1318
+
type: 'string',
1319
+
description: 'The handle of the listener.',
1320
+
},
1321
+
displayName: {
1322
+
type: 'string',
1323
+
description: 'The display name of the listener.',
1324
+
},
1325
+
avatar: {
1326
+
type: 'string',
1327
+
description: "The URL of the listener's avatar image.",
1328
+
format: 'uri',
1329
+
},
1330
+
mostListenedSong: {
1331
+
type: 'ref',
1332
+
ref: 'lex:app.rocksky.artist.defs#songViewBasic',
1333
+
},
1334
+
totalPlays: {
1335
+
type: 'integer',
1336
+
description: 'The total number of plays by the listener.',
1337
+
minimum: 0,
1338
+
},
1339
+
rank: {
1340
+
type: 'integer',
1341
+
description:
1342
+
'The rank of the listener among all listeners of the artist.',
1343
+
minimum: 1,
1344
+
},
1345
+
},
1346
+
},
1347
+
artistMbid: {
1348
+
type: 'object',
1349
+
properties: {
1350
+
mbid: {
1351
+
type: 'string',
1352
+
description: 'The MusicBrainz Identifier (MBID) of the artist.',
1353
+
},
1354
+
name: {
1355
+
type: 'string',
1356
+
description: 'The name of the artist.',
1357
+
minLength: 1,
1358
+
maxLength: 256,
1359
+
},
1360
+
},
1361
+
},
1362
+
},
1363
+
},
1364
+
AppRockskyArtistGetArtist: {
1365
+
lexicon: 1,
1366
+
id: 'app.rocksky.artist.getArtist',
1367
+
defs: {
1368
+
main: {
1369
+
type: 'query',
1370
+
description: 'Get artist details',
1371
+
parameters: {
1372
+
type: 'params',
1373
+
required: ['uri'],
1374
+
properties: {
1375
+
uri: {
1376
+
type: 'string',
1377
+
description: 'The URI of the artist to retrieve details from',
1378
+
format: 'at-uri',
1379
+
},
1380
+
},
1381
+
},
1382
+
output: {
1383
+
encoding: 'application/json',
1384
+
schema: {
1385
+
type: 'ref',
1386
+
ref: 'lex:app.rocksky.artist.defs#artistViewDetailed',
1387
+
},
1388
+
},
1389
+
},
1390
+
},
1391
+
},
1392
+
AppRockskyArtistGetArtistAlbums: {
1393
+
lexicon: 1,
1394
+
id: 'app.rocksky.artist.getArtistAlbums',
1395
+
defs: {
1396
+
main: {
1397
+
type: 'query',
1398
+
description: "Get artist's albums",
1399
+
parameters: {
1400
+
type: 'params',
1401
+
required: ['uri'],
1402
+
properties: {
1403
+
uri: {
1404
+
type: 'string',
1405
+
description: 'The URI of the artist to retrieve albums from',
1406
+
format: 'at-uri',
1407
+
},
1408
+
},
1409
+
},
1410
+
output: {
1411
+
encoding: 'application/json',
1412
+
schema: {
1413
+
type: 'object',
1414
+
properties: {
1415
+
albums: {
1416
+
type: 'array',
1417
+
items: {
1418
+
type: 'ref',
1419
+
ref: 'lex:app.rocksky.album.defs#albumViewBasic',
1420
+
},
1421
+
},
1422
+
},
1423
+
},
1424
+
},
1425
+
},
1426
+
},
1427
+
},
1428
+
AppRockskyArtistGetArtistListeners: {
1429
+
lexicon: 1,
1430
+
id: 'app.rocksky.artist.getArtistListeners',
1431
+
defs: {
1432
+
main: {
1433
+
type: 'query',
1434
+
description: 'Get artist listeners',
1435
+
parameters: {
1436
+
type: 'params',
1437
+
required: ['uri'],
1438
+
properties: {
1439
+
uri: {
1440
+
type: 'string',
1441
+
description: 'The URI of the artist to retrieve listeners from',
1442
+
format: 'at-uri',
1443
+
},
1444
+
offset: {
1445
+
type: 'integer',
1446
+
description: 'Number of items to skip before returning results',
1447
+
},
1448
+
limit: {
1449
+
type: 'integer',
1450
+
description: 'Maximum number of results to return',
1451
+
},
1452
+
},
1453
+
},
1454
+
output: {
1455
+
encoding: 'application/json',
1456
+
schema: {
1457
+
type: 'object',
1458
+
properties: {
1459
+
listeners: {
1460
+
type: 'array',
1461
+
items: {
1462
+
type: 'ref',
1463
+
ref: 'lex:app.rocksky.artist.defs#listenerViewBasic',
1464
+
},
1465
+
},
1466
+
},
1467
+
},
1468
+
},
1469
+
},
1470
+
},
1471
+
},
1472
+
AppRockskyArtistGetArtists: {
1473
+
lexicon: 1,
1474
+
id: 'app.rocksky.artist.getArtists',
1475
+
defs: {
1476
+
main: {
1477
+
type: 'query',
1478
+
description: 'Get artists',
1479
+
parameters: {
1480
+
type: 'params',
1481
+
properties: {
1482
+
limit: {
1483
+
type: 'integer',
1484
+
description: 'The maximum number of artists to return',
1485
+
minimum: 1,
1486
+
},
1487
+
offset: {
1488
+
type: 'integer',
1489
+
description: 'The offset for pagination',
1490
+
minimum: 0,
1491
+
},
1492
+
names: {
1493
+
type: 'string',
1494
+
description: 'The names of the artists to return',
1495
+
},
1496
+
},
1497
+
},
1498
+
output: {
1499
+
encoding: 'application/json',
1500
+
schema: {
1501
+
type: 'object',
1502
+
properties: {
1503
+
artists: {
1504
+
type: 'array',
1505
+
items: {
1506
+
type: 'ref',
1507
+
ref: 'lex:app.rocksky.artist.defs#artistViewBasic',
1508
+
},
1509
+
},
1510
+
},
1511
+
},
1512
+
},
1513
+
},
1514
+
},
1515
+
},
1516
+
AppRockskyArtistGetArtistTracks: {
1517
+
lexicon: 1,
1518
+
id: 'app.rocksky.artist.getArtistTracks',
1519
+
defs: {
1520
+
main: {
1521
+
type: 'query',
1522
+
description: "Get artist's tracks",
1523
+
parameters: {
1524
+
type: 'params',
1525
+
properties: {
1526
+
uri: {
1527
+
type: 'string',
1528
+
description: 'The URI of the artist to retrieve albums from',
1529
+
format: 'at-uri',
1530
+
},
1531
+
limit: {
1532
+
type: 'integer',
1533
+
description: 'The maximum number of tracks to return',
1534
+
minimum: 1,
1535
+
},
1536
+
offset: {
1537
+
type: 'integer',
1538
+
description: 'The offset for pagination',
1539
+
minimum: 0,
1540
+
},
1541
+
},
1542
+
},
1543
+
output: {
1544
+
encoding: 'application/json',
1545
+
schema: {
1546
+
type: 'object',
1547
+
properties: {
1548
+
tracks: {
1549
+
type: 'array',
1550
+
items: {
1551
+
type: 'ref',
1552
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
1553
+
},
1554
+
},
1555
+
},
1556
+
},
1557
+
},
1558
+
},
1559
+
},
1560
+
},
1561
+
AppRockskyChartsDefs: {
1562
+
lexicon: 1,
1563
+
id: 'app.rocksky.charts.defs',
1564
+
defs: {
1565
+
chartsView: {
1566
+
type: 'object',
1567
+
properties: {
1568
+
scrobbles: {
1569
+
type: 'array',
1570
+
items: {
1571
+
type: 'ref',
1572
+
ref: 'lex:app.rocksky.charts.defs#scrobbleViewBasic',
1573
+
},
1574
+
},
1575
+
},
1576
+
},
1577
+
scrobbleViewBasic: {
1578
+
type: 'object',
1579
+
properties: {
1580
+
date: {
1581
+
type: 'string',
1582
+
description: 'The date of the scrobble.',
1583
+
format: 'datetime',
1584
+
},
1585
+
count: {
1586
+
type: 'integer',
1587
+
description: 'The number of scrobbles on this date.',
1588
+
},
1589
+
},
1590
+
},
1591
+
},
1592
+
},
1593
+
AppRockskyChartsGetScrobblesChart: {
1594
+
lexicon: 1,
1595
+
id: 'app.rocksky.charts.getScrobblesChart',
1596
+
defs: {
1597
+
main: {
1598
+
type: 'query',
1599
+
description: 'Get the scrobbles chart',
1600
+
parameters: {
1601
+
type: 'params',
1602
+
properties: {
1603
+
did: {
1604
+
type: 'string',
1605
+
description: 'The DID or handle of the actor',
1606
+
format: 'at-identifier',
1607
+
},
1608
+
artisturi: {
1609
+
type: 'string',
1610
+
description: 'The URI of the artist to filter by',
1611
+
format: 'at-uri',
1612
+
},
1613
+
albumuri: {
1614
+
type: 'string',
1615
+
description: 'The URI of the album to filter by',
1616
+
format: 'at-uri',
1617
+
},
1618
+
songuri: {
1619
+
type: 'string',
1620
+
description: 'The URI of the track to filter by',
1621
+
format: 'at-uri',
1622
+
},
1623
+
},
1624
+
},
1625
+
output: {
1626
+
encoding: 'application/json',
1627
+
schema: {
1628
+
type: 'ref',
1629
+
ref: 'lex:app.rocksky.charts.defs#chartsView',
1630
+
},
1631
+
},
1632
+
},
1633
+
},
1634
+
},
1635
+
AppRockskyDropboxDefs: {
1636
+
lexicon: 1,
1637
+
id: 'app.rocksky.dropbox.defs',
1638
+
defs: {
1639
+
fileView: {
1640
+
type: 'object',
1641
+
properties: {
1642
+
id: {
1643
+
type: 'string',
1644
+
description: 'The unique identifier of the file.',
1645
+
},
1646
+
name: {
1647
+
type: 'string',
1648
+
description: 'The name of the file.',
1649
+
},
1650
+
pathLower: {
1651
+
type: 'string',
1652
+
description: 'The lowercased path of the file.',
1653
+
},
1654
+
pathDisplay: {
1655
+
type: 'string',
1656
+
description: 'The display path of the file.',
1657
+
},
1658
+
clientModified: {
1659
+
type: 'string',
1660
+
description:
1661
+
'The last modified date and time of the file on the client.',
1662
+
format: 'datetime',
1663
+
},
1664
+
serverModified: {
1665
+
type: 'string',
1666
+
description:
1667
+
'The last modified date and time of the file on the server.',
1668
+
format: 'datetime',
1669
+
},
1670
+
},
1671
+
},
1672
+
fileListView: {
1673
+
type: 'object',
1674
+
properties: {
1675
+
files: {
1676
+
type: 'array',
1677
+
description: 'A list of files in the Dropbox.',
1678
+
items: {
1679
+
type: 'ref',
1680
+
ref: 'lex:app.rocksky.dropbox.defs#fileView',
1681
+
},
1682
+
},
1683
+
},
1684
+
},
1685
+
temporaryLinkView: {
1686
+
type: 'object',
1687
+
properties: {
1688
+
link: {
1689
+
type: 'string',
1690
+
description: 'The temporary link to access the file.',
1691
+
format: 'uri',
1692
+
},
1693
+
},
1694
+
},
1695
+
},
1696
+
},
1697
+
AppRockskyDropboxDownloadFile: {
1698
+
lexicon: 1,
1699
+
id: 'app.rocksky.dropbox.downloadFile',
1700
+
defs: {
1701
+
main: {
1702
+
type: 'query',
1703
+
description: 'Download a file from Dropbox by its unique identifier',
1704
+
parameters: {
1705
+
type: 'params',
1706
+
required: ['fileId'],
1707
+
properties: {
1708
+
fileId: {
1709
+
type: 'string',
1710
+
description: 'The unique identifier of the file to download',
1711
+
},
1712
+
},
1713
+
},
1714
+
output: {
1715
+
encoding: 'application/octet-stream',
1716
+
},
1717
+
},
1718
+
},
1719
+
},
1720
+
AppRockskyDropboxGetFiles: {
1721
+
lexicon: 1,
1722
+
id: 'app.rocksky.dropbox.getFiles',
1723
+
defs: {
1724
+
main: {
1725
+
type: 'query',
1726
+
description: 'Retrieve a list of files from Dropbox',
1727
+
parameters: {
1728
+
type: 'params',
1729
+
properties: {
1730
+
at: {
1731
+
type: 'string',
1732
+
description: 'Path to the Dropbox folder or root directory',
1733
+
},
1734
+
},
1735
+
},
1736
+
output: {
1737
+
encoding: 'application/json',
1738
+
schema: {
1739
+
type: 'ref',
1740
+
ref: 'lex:app.rocksky.dropbox.defs#fileListView',
1741
+
},
1742
+
},
1743
+
},
1744
+
},
1745
+
},
1746
+
AppRockskyDropboxGetMetadata: {
1747
+
lexicon: 1,
1748
+
id: 'app.rocksky.dropbox.getMetadata',
1749
+
defs: {
1750
+
main: {
1751
+
type: 'query',
1752
+
description: 'Retrieve metadata of a file or folder in Dropbox',
1753
+
parameters: {
1754
+
type: 'params',
1755
+
required: ['path'],
1756
+
properties: {
1757
+
path: {
1758
+
type: 'string',
1759
+
description: 'Path to the file or folder in Dropbox',
1760
+
},
1761
+
},
1762
+
},
1763
+
output: {
1764
+
encoding: 'application/json',
1765
+
schema: {
1766
+
type: 'ref',
1767
+
ref: 'lex:app.rocksky.dropbox.defs#fileView',
1768
+
},
1769
+
},
1770
+
},
1771
+
},
1772
+
},
1773
+
AppRockskyDropboxGetTemporaryLink: {
1774
+
lexicon: 1,
1775
+
id: 'app.rocksky.dropbox.getTemporaryLink',
1776
+
defs: {
1777
+
main: {
1778
+
type: 'query',
1779
+
description: 'Retrieve a temporary link to access a file in Dropbox',
1780
+
parameters: {
1781
+
type: 'params',
1782
+
required: ['path'],
1783
+
properties: {
1784
+
path: {
1785
+
type: 'string',
1786
+
description: 'Path to the file in Dropbox',
1787
+
},
1788
+
},
1789
+
},
1790
+
output: {
1791
+
encoding: 'application/json',
1792
+
schema: {
1793
+
type: 'ref',
1794
+
ref: 'lex:app.rocksky.dropbox.defs#temporaryLinkView',
1795
+
},
1796
+
},
1797
+
},
1798
+
},
1799
+
},
1800
+
AppRockskyFeedDefs: {
1801
+
lexicon: 1,
1802
+
id: 'app.rocksky.feed.defs',
1803
+
defs: {
1804
+
searchResultsView: {
1805
+
type: 'object',
1806
+
properties: {
1807
+
hits: {
1808
+
type: 'array',
1809
+
items: {
1810
+
type: 'union',
1811
+
refs: [
1812
+
'lex:app.rocksky.song.defs#songViewBasic',
1813
+
'lex:app.rocksky.album.defs#albumViewBasic',
1814
+
'lex:app.rocksky.artist.defs#artistViewBasic',
1815
+
'lex:app.rocksky.playlist.defs#playlistViewBasic',
1816
+
'lex:app.rocksky.actor.defs#profileViewBasic',
1817
+
],
1818
+
},
1819
+
},
1820
+
processingTimeMs: {
1821
+
type: 'integer',
1822
+
},
1823
+
limit: {
1824
+
type: 'integer',
1825
+
},
1826
+
offset: {
1827
+
type: 'integer',
1828
+
},
1829
+
estimatedTotalHits: {
1830
+
type: 'integer',
1831
+
},
1832
+
},
1833
+
},
1834
+
nowPlayingView: {
1835
+
type: 'object',
1836
+
properties: {
1837
+
album: {
1838
+
type: 'string',
1839
+
},
1840
+
albumArt: {
1841
+
type: 'string',
1842
+
format: 'uri',
1843
+
},
1844
+
albumArtist: {
1845
+
type: 'string',
1846
+
},
1847
+
albumUri: {
1848
+
type: 'string',
1849
+
format: 'at-uri',
1850
+
},
1851
+
artist: {
1852
+
type: 'string',
1853
+
},
1854
+
artistUri: {
1855
+
type: 'string',
1856
+
format: 'at-uri',
1857
+
},
1858
+
avatar: {
1859
+
type: 'string',
1860
+
format: 'uri',
1861
+
},
1862
+
createdAt: {
1863
+
type: 'string',
1864
+
},
1865
+
did: {
1866
+
type: 'string',
1867
+
format: 'at-identifier',
1868
+
},
1869
+
handle: {
1870
+
type: 'string',
1871
+
},
1872
+
id: {
1873
+
type: 'string',
1874
+
},
1875
+
title: {
1876
+
type: 'string',
1877
+
},
1878
+
trackId: {
1879
+
type: 'string',
1880
+
},
1881
+
trackUri: {
1882
+
type: 'string',
1883
+
format: 'at-uri',
1884
+
},
1885
+
uri: {
1886
+
type: 'string',
1887
+
format: 'at-uri',
1888
+
},
1889
+
},
1890
+
},
1891
+
nowPlayingsView: {
1892
+
type: 'object',
1893
+
properties: {
1894
+
nowPlayings: {
1895
+
type: 'array',
1896
+
items: {
1897
+
type: 'ref',
1898
+
ref: 'lex:app.rocksky.feed.defs#nowPlayingView',
1899
+
},
1900
+
},
1901
+
},
1902
+
},
1903
+
feedGeneratorsView: {
1904
+
type: 'object',
1905
+
properties: {
1906
+
feeds: {
1907
+
type: 'array',
1908
+
items: {
1909
+
type: 'ref',
1910
+
ref: 'lex:app.rocksky.feed.defs#feedGeneratorView',
1911
+
},
1912
+
},
1913
+
},
1914
+
},
1915
+
feedGeneratorView: {
1916
+
type: 'object',
1917
+
properties: {
1918
+
id: {
1919
+
type: 'string',
1920
+
},
1921
+
name: {
1922
+
type: 'string',
1923
+
},
1924
+
description: {
1925
+
type: 'string',
1926
+
},
1927
+
uri: {
1928
+
type: 'string',
1929
+
format: 'at-uri',
1930
+
},
1931
+
avatar: {
1932
+
type: 'string',
1933
+
format: 'uri',
1934
+
},
1935
+
creator: {
1936
+
type: 'ref',
1937
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
1938
+
},
1939
+
},
1940
+
},
1941
+
feedUriView: {
1942
+
type: 'object',
1943
+
properties: {
1944
+
uri: {
1945
+
type: 'string',
1946
+
description: 'The feed URI.',
1947
+
format: 'at-uri',
1948
+
},
1949
+
},
1950
+
},
1951
+
feedItemView: {
1952
+
type: 'object',
1953
+
properties: {
1954
+
scrobble: {
1955
+
type: 'ref',
1956
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
1957
+
},
1958
+
},
1959
+
},
1960
+
feedView: {
1961
+
type: 'object',
1962
+
properties: {
1963
+
feed: {
1964
+
type: 'array',
1965
+
items: {
1966
+
type: 'ref',
1967
+
ref: 'lex:app.rocksky.feed.defs#feedItemView',
1968
+
},
1969
+
},
1970
+
cursor: {
1971
+
type: 'string',
1972
+
description: 'The pagination cursor for the next set of results.',
1973
+
},
1974
+
},
1975
+
},
1976
+
},
1977
+
},
1978
+
AppRockskyFeedDescribeFeedGenerator: {
1979
+
lexicon: 1,
1980
+
id: 'app.rocksky.feed.describeFeedGenerator',
1981
+
defs: {
1982
+
main: {
1983
+
type: 'query',
1984
+
description: 'Get information about a feed generator',
1985
+
parameters: {
1986
+
type: 'params',
1987
+
properties: {},
1988
+
},
1989
+
output: {
1990
+
encoding: 'application/json',
1991
+
schema: {
1992
+
type: 'object',
1993
+
properties: {
1994
+
did: {
1995
+
type: 'string',
1996
+
description: 'The DID of the feed generator.',
1997
+
format: 'at-identifier',
1998
+
},
1999
+
feeds: {
2000
+
type: 'array',
2001
+
description:
2002
+
'List of feed URIs generated by this feed generator.',
2003
+
items: {
2004
+
type: 'ref',
2005
+
ref: 'lex:app.rocksky.feed.defs#feedUriView',
2006
+
},
2007
+
},
2008
+
},
2009
+
},
2010
+
},
2011
+
},
2012
+
},
2013
+
},
2014
+
AppRockskyFeedGenerator: {
2015
+
lexicon: 1,
2016
+
id: 'app.rocksky.feed.generator',
2017
+
defs: {
2018
+
main: {
2019
+
type: 'record',
2020
+
description:
2021
+
'Record declaring of the existence of a feed generator, and containing metadata about it. The record can exist in any repository.',
2022
+
key: 'tid',
2023
+
record: {
2024
+
type: 'object',
2025
+
required: ['did', 'displayName', 'createdAt'],
2026
+
properties: {
2027
+
did: {
2028
+
type: 'string',
2029
+
format: 'did',
2030
+
},
2031
+
avatar: {
2032
+
type: 'blob',
2033
+
accept: ['image/png', 'image/jpeg'],
2034
+
maxSize: 1000000,
2035
+
},
2036
+
displayName: {
2037
+
type: 'string',
2038
+
maxGraphemes: 24,
2039
+
maxLength: 240,
2040
+
},
2041
+
description: {
2042
+
type: 'string',
2043
+
maxGraphemes: 300,
2044
+
maxLength: 3000,
2045
+
},
2046
+
createdAt: {
2047
+
type: 'string',
2048
+
format: 'datetime',
2049
+
},
2050
+
},
2051
+
},
2052
+
},
2053
+
},
2054
+
},
2055
+
AppRockskyFeedGetFeed: {
2056
+
lexicon: 1,
2057
+
id: 'app.rocksky.feed.getFeed',
2058
+
defs: {
2059
+
main: {
2060
+
type: 'query',
2061
+
description: 'Get the feed by uri',
2062
+
parameters: {
2063
+
type: 'params',
2064
+
required: ['feed'],
2065
+
properties: {
2066
+
feed: {
2067
+
type: 'string',
2068
+
description: 'The feed URI.',
2069
+
format: 'at-uri',
2070
+
},
2071
+
limit: {
2072
+
type: 'integer',
2073
+
description: 'The maximum number of scrobbles to return',
2074
+
minimum: 1,
2075
+
},
2076
+
cursor: {
2077
+
type: 'string',
2078
+
description: 'The cursor for pagination',
2079
+
},
2080
+
},
2081
+
},
2082
+
output: {
2083
+
encoding: 'application/json',
2084
+
schema: {
2085
+
type: 'ref',
2086
+
ref: 'lex:app.rocksky.feed.defs#feedView',
2087
+
},
2088
+
},
2089
+
},
2090
+
},
2091
+
},
2092
+
AppRockskyFeedGetFeedGenerator: {
2093
+
lexicon: 1,
2094
+
id: 'app.rocksky.feed.getFeedGenerator',
2095
+
defs: {
2096
+
main: {
2097
+
type: 'query',
2098
+
description: 'Get information about a feed generator',
2099
+
parameters: {
2100
+
type: 'params',
2101
+
required: ['feed'],
2102
+
properties: {
2103
+
feed: {
2104
+
type: 'string',
2105
+
description: 'AT-URI of the feed generator record.',
2106
+
format: 'at-uri',
2107
+
},
2108
+
},
2109
+
},
2110
+
output: {
2111
+
encoding: 'application/json',
2112
+
schema: {
2113
+
type: 'object',
2114
+
properties: {
2115
+
view: {
2116
+
type: 'ref',
2117
+
ref: 'lex:app.rocksky.feed.defs#feedGeneratorView',
2118
+
},
2119
+
},
2120
+
},
2121
+
},
2122
+
},
2123
+
},
2124
+
},
2125
+
AppRockskyFeedGetFeedGenerators: {
2126
+
lexicon: 1,
2127
+
id: 'app.rocksky.feed.getFeedGenerators',
2128
+
defs: {
2129
+
main: {
2130
+
type: 'query',
2131
+
description: 'Get all feed generators',
2132
+
parameters: {
2133
+
type: 'params',
2134
+
properties: {
2135
+
size: {
2136
+
type: 'integer',
2137
+
description: 'The maximum number of feed generators to return.',
2138
+
minimum: 1,
2139
+
},
2140
+
},
2141
+
},
2142
+
output: {
2143
+
encoding: 'application/json',
2144
+
schema: {
2145
+
type: 'ref',
2146
+
ref: 'lex:app.rocksky.feed.defs#feedGeneratorsView',
2147
+
},
2148
+
},
2149
+
},
2150
+
},
2151
+
},
2152
+
AppRockskyFeedGetFeedSkeleton: {
2153
+
lexicon: 1,
2154
+
id: 'app.rocksky.feed.getFeedSkeleton',
2155
+
defs: {
2156
+
main: {
2157
+
type: 'query',
2158
+
description: 'Get the feed by uri',
2159
+
parameters: {
2160
+
type: 'params',
2161
+
required: ['feed'],
2162
+
properties: {
2163
+
feed: {
2164
+
type: 'string',
2165
+
description: 'The feed URI.',
2166
+
format: 'at-uri',
2167
+
},
2168
+
limit: {
2169
+
type: 'integer',
2170
+
description: 'The maximum number of scrobbles to return',
2171
+
minimum: 1,
2172
+
},
2173
+
offset: {
2174
+
type: 'integer',
2175
+
description: 'The offset for pagination',
2176
+
minimum: 0,
2177
+
},
2178
+
cursor: {
2179
+
type: 'string',
2180
+
description: 'The pagination cursor.',
2181
+
},
2182
+
},
2183
+
},
2184
+
output: {
2185
+
encoding: 'application/json',
2186
+
schema: {
2187
+
type: 'object',
2188
+
properties: {
2189
+
scrobbles: {
2190
+
type: 'array',
2191
+
items: {
2192
+
type: 'ref',
2193
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
2194
+
},
2195
+
},
2196
+
cursor: {
2197
+
type: 'string',
2198
+
description:
2199
+
'The pagination cursor for the next set of results.',
2200
+
},
2201
+
},
2202
+
},
2203
+
},
2204
+
},
2205
+
},
2206
+
},
2207
+
AppRockskyFeedGetNowPlayings: {
2208
+
lexicon: 1,
2209
+
id: 'app.rocksky.feed.getNowPlayings',
2210
+
defs: {
2211
+
main: {
2212
+
type: 'query',
2213
+
description: 'Get all currently playing tracks by users',
2214
+
parameters: {
2215
+
type: 'params',
2216
+
properties: {
2217
+
size: {
2218
+
type: 'integer',
2219
+
description:
2220
+
'The maximum number of now playing tracks to return.',
2221
+
minimum: 1,
2222
+
},
2223
+
},
2224
+
},
2225
+
output: {
2226
+
encoding: 'application/json',
2227
+
schema: {
2228
+
type: 'ref',
2229
+
ref: 'lex:app.rocksky.feed.defs#nowPlayingsView',
2230
+
},
2231
+
},
2232
+
},
2233
+
},
2234
+
},
2235
+
AppRockskyFeedSearch: {
2236
+
lexicon: 1,
2237
+
id: 'app.rocksky.feed.search',
2238
+
defs: {
2239
+
main: {
2240
+
type: 'query',
2241
+
description: 'Search for content in the feed',
2242
+
parameters: {
2243
+
type: 'params',
2244
+
required: ['query'],
2245
+
properties: {
2246
+
query: {
2247
+
type: 'string',
2248
+
description: 'The search query string',
2249
+
},
2250
+
},
2251
+
},
2252
+
output: {
2253
+
encoding: 'application/json',
2254
+
schema: {
2255
+
type: 'ref',
2256
+
ref: 'lex:app.rocksky.feed.defs#searchResultsView',
2257
+
},
2258
+
},
2259
+
},
2260
+
},
2261
+
},
2262
+
AppRockskyGoogledriveDefs: {
2263
+
lexicon: 1,
2264
+
id: 'app.rocksky.googledrive.defs',
2265
+
defs: {
2266
+
fileView: {
2267
+
type: 'object',
2268
+
properties: {
2269
+
id: {
2270
+
type: 'string',
2271
+
description: 'The unique identifier of the file.',
2272
+
},
2273
+
},
2274
+
},
2275
+
fileListView: {
2276
+
type: 'object',
2277
+
properties: {
2278
+
files: {
2279
+
type: 'array',
2280
+
items: {
2281
+
type: 'ref',
2282
+
ref: 'lex:app.rocksky.googledrive.defs#fileView',
2283
+
},
2284
+
},
2285
+
},
2286
+
},
2287
+
},
2288
+
},
2289
+
AppRockskyGoogledriveDownloadFile: {
2290
+
lexicon: 1,
2291
+
id: 'app.rocksky.googledrive.downloadFile',
2292
+
defs: {
2293
+
main: {
2294
+
type: 'query',
2295
+
description:
2296
+
'Download a file from Google Drive by its unique identifier',
2297
+
parameters: {
2298
+
type: 'params',
2299
+
required: ['fileId'],
2300
+
properties: {
2301
+
fileId: {
2302
+
type: 'string',
2303
+
description: 'The unique identifier of the file to download',
2304
+
},
2305
+
},
2306
+
},
2307
+
output: {
2308
+
encoding: 'application/octet-stream',
2309
+
},
2310
+
},
2311
+
},
2312
+
},
2313
+
AppRockskyGoogledriveGetFile: {
2314
+
lexicon: 1,
2315
+
id: 'app.rocksky.googledrive.getFile',
2316
+
defs: {
2317
+
main: {
2318
+
type: 'query',
2319
+
description: 'Get a file from Google Drive by its unique identifier',
2320
+
parameters: {
2321
+
type: 'params',
2322
+
required: ['fileId'],
2323
+
properties: {
2324
+
fileId: {
2325
+
type: 'string',
2326
+
description: 'The unique identifier of the file to retrieve',
2327
+
},
2328
+
},
2329
+
},
2330
+
output: {
2331
+
encoding: 'application/json',
2332
+
schema: {
2333
+
type: 'ref',
2334
+
ref: 'lex:app.rocksky.googledrive.defs#fileView',
2335
+
},
2336
+
},
2337
+
},
2338
+
},
2339
+
},
2340
+
AppRockskyGoogledriveGetFiles: {
2341
+
lexicon: 1,
2342
+
id: 'app.rocksky.googledrive.getFiles',
2343
+
defs: {
2344
+
main: {
2345
+
type: 'query',
2346
+
description: 'Get a list of files from Google Drive',
2347
+
parameters: {
2348
+
type: 'params',
2349
+
properties: {
2350
+
at: {
2351
+
type: 'string',
2352
+
description: 'Path to the Google Drive folder or root directory',
2353
+
},
2354
+
},
2355
+
},
2356
+
output: {
2357
+
encoding: 'application/json',
2358
+
schema: {
2359
+
type: 'ref',
2360
+
ref: 'lex:app.rocksky.googledrive.defs#fileListView',
2361
+
},
2362
+
},
2363
+
},
2364
+
},
2365
+
},
2366
+
AppRockskyGraphDefs: {
2367
+
lexicon: 1,
2368
+
id: 'app.rocksky.graph.defs',
2369
+
defs: {
2370
+
notFoundActor: {
2371
+
type: 'object',
2372
+
description: 'indicates that a handle or DID could not be resolved',
2373
+
required: ['actor', 'notFound'],
2374
+
properties: {
2375
+
actor: {
2376
+
type: 'string',
2377
+
format: 'at-identifier',
2378
+
},
2379
+
notFound: {
2380
+
type: 'boolean',
2381
+
},
2382
+
},
2383
+
},
2384
+
relationship: {
2385
+
type: 'object',
2386
+
required: ['did'],
2387
+
properties: {
2388
+
did: {
2389
+
type: 'string',
2390
+
format: 'did',
2391
+
},
2392
+
following: {
2393
+
type: 'string',
2394
+
description:
2395
+
'if the actor follows this DID, this is the AT-URI of the follow record',
2396
+
format: 'at-uri',
2397
+
},
2398
+
followedBy: {
2399
+
type: 'string',
2400
+
description:
2401
+
'if the actor is followed by this DID, contains the AT-URI of the follow record',
2402
+
format: 'at-uri',
2403
+
},
2404
+
},
2405
+
},
2406
+
},
2407
+
},
2408
+
AppRockskyGraphFollow: {
2409
+
lexicon: 1,
2410
+
id: 'app.rocksky.graph.follow',
2411
+
defs: {
2412
+
main: {
2413
+
type: 'record',
2414
+
description:
2415
+
"Record declaring a social 'follow' relationship of another account.",
2416
+
key: 'tid',
2417
+
record: {
2418
+
type: 'object',
2419
+
required: ['createdAt', 'subject'],
2420
+
properties: {
2421
+
createdAt: {
2422
+
type: 'string',
2423
+
format: 'datetime',
2424
+
},
2425
+
subject: {
2426
+
type: 'string',
2427
+
format: 'did',
2428
+
},
2429
+
via: {
2430
+
type: 'ref',
2431
+
ref: 'lex:com.atproto.repo.strongRef',
2432
+
},
2433
+
},
2434
+
},
2435
+
},
2436
+
},
2437
+
},
2438
+
AppRockskyGraphFollowAccount: {
2439
+
lexicon: 1,
2440
+
id: 'app.rocksky.graph.followAccount',
2441
+
defs: {
2442
+
main: {
2443
+
type: 'procedure',
2444
+
description:
2445
+
"Creates a 'follow' relationship from the authenticated account to a specified account.",
2446
+
parameters: {
2447
+
type: 'params',
2448
+
required: ['account'],
2449
+
properties: {
2450
+
account: {
2451
+
type: 'string',
2452
+
format: 'at-identifier',
2453
+
},
2454
+
},
2455
+
},
2456
+
output: {
2457
+
encoding: 'application/json',
2458
+
schema: {
2459
+
type: 'object',
2460
+
required: ['subject', 'followers'],
2461
+
properties: {
2462
+
subject: {
2463
+
type: 'ref',
2464
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2465
+
},
2466
+
followers: {
2467
+
type: 'array',
2468
+
items: {
2469
+
type: 'ref',
2470
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2471
+
},
2472
+
},
2473
+
cursor: {
2474
+
type: 'string',
2475
+
description:
2476
+
'A cursor value to pass to subsequent calls to get the next page of results.',
2477
+
},
2478
+
},
2479
+
},
2480
+
},
2481
+
},
2482
+
},
2483
+
},
2484
+
AppRockskyGraphGetFollowers: {
2485
+
lexicon: 1,
2486
+
id: 'app.rocksky.graph.getFollowers',
2487
+
defs: {
2488
+
main: {
2489
+
type: 'query',
2490
+
description:
2491
+
'Enumerates accounts which follow a specified account (actor).',
2492
+
parameters: {
2493
+
type: 'params',
2494
+
required: ['actor'],
2495
+
properties: {
2496
+
actor: {
2497
+
type: 'string',
2498
+
format: 'at-identifier',
2499
+
},
2500
+
limit: {
2501
+
type: 'integer',
2502
+
maximum: 100,
2503
+
minimum: 1,
2504
+
default: 50,
2505
+
},
2506
+
dids: {
2507
+
type: 'array',
2508
+
description:
2509
+
'If provided, filters the followers to only include those with DIDs in this list.',
2510
+
items: {
2511
+
type: 'string',
2512
+
format: 'did',
2513
+
},
2514
+
},
2515
+
cursor: {
2516
+
type: 'string',
2517
+
},
2518
+
},
2519
+
},
2520
+
output: {
2521
+
encoding: 'application/json',
2522
+
schema: {
2523
+
type: 'object',
2524
+
required: ['subject', 'followers'],
2525
+
properties: {
2526
+
subject: {
2527
+
type: 'ref',
2528
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2529
+
},
2530
+
followers: {
2531
+
type: 'array',
2532
+
items: {
2533
+
type: 'ref',
2534
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2535
+
},
2536
+
},
2537
+
cursor: {
2538
+
type: 'string',
2539
+
description:
2540
+
'A cursor value to pass to subsequent calls to get the next page of results.',
2541
+
},
2542
+
count: {
2543
+
type: 'integer',
2544
+
description: 'The total number of followers.',
2545
+
},
2546
+
},
2547
+
},
2548
+
},
2549
+
},
2550
+
},
2551
+
},
2552
+
AppRockskyGraphGetFollows: {
2553
+
lexicon: 1,
2554
+
id: 'app.rocksky.graph.getFollows',
2555
+
defs: {
2556
+
main: {
2557
+
type: 'query',
2558
+
description:
2559
+
'Enumerates accounts which a specified account (actor) follows.',
2560
+
parameters: {
2561
+
type: 'params',
2562
+
required: ['actor'],
2563
+
properties: {
2564
+
actor: {
2565
+
type: 'string',
2566
+
format: 'at-identifier',
2567
+
},
2568
+
limit: {
2569
+
type: 'integer',
2570
+
maximum: 100,
2571
+
minimum: 1,
2572
+
default: 50,
2573
+
},
2574
+
dids: {
2575
+
type: 'array',
2576
+
description:
2577
+
'If provided, filters the follows to only include those with DIDs in this list.',
2578
+
items: {
2579
+
type: 'string',
2580
+
format: 'did',
2581
+
},
2582
+
},
2583
+
cursor: {
2584
+
type: 'string',
2585
+
},
2586
+
},
2587
+
},
2588
+
output: {
2589
+
encoding: 'application/json',
2590
+
schema: {
2591
+
type: 'object',
2592
+
required: ['subject', 'follows'],
2593
+
properties: {
2594
+
subject: {
2595
+
type: 'ref',
2596
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2597
+
},
2598
+
follows: {
2599
+
type: 'array',
2600
+
items: {
2601
+
type: 'ref',
2602
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2603
+
},
2604
+
},
2605
+
cursor: {
2606
+
type: 'string',
2607
+
description:
2608
+
'A cursor value to pass to subsequent calls to get the next page of results.',
2609
+
},
2610
+
count: {
2611
+
type: 'integer',
2612
+
description: 'The total number of follows.',
2613
+
},
2614
+
},
2615
+
},
2616
+
},
2617
+
},
2618
+
},
2619
+
},
2620
+
AppRockskyGraphGetKnownFollowers: {
2621
+
lexicon: 1,
2622
+
id: 'app.rocksky.graph.getKnownFollowers',
2623
+
defs: {
2624
+
main: {
2625
+
type: 'query',
2626
+
description:
2627
+
'Enumerates accounts which follow a specified account (actor) and are followed by the viewer.',
2628
+
parameters: {
2629
+
type: 'params',
2630
+
required: ['actor'],
2631
+
properties: {
2632
+
actor: {
2633
+
type: 'string',
2634
+
format: 'at-identifier',
2635
+
},
2636
+
limit: {
2637
+
type: 'integer',
2638
+
maximum: 100,
2639
+
minimum: 1,
2640
+
default: 50,
2641
+
},
2642
+
cursor: {
2643
+
type: 'string',
2644
+
},
2645
+
},
2646
+
},
2647
+
output: {
2648
+
encoding: 'application/json',
2649
+
schema: {
2650
+
type: 'object',
2651
+
required: ['subject', 'followers'],
2652
+
properties: {
2653
+
subject: {
2654
+
type: 'ref',
2655
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2656
+
},
2657
+
followers: {
2658
+
type: 'array',
2659
+
items: {
2660
+
type: 'ref',
2661
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2662
+
},
2663
+
},
2664
+
cursor: {
2665
+
type: 'string',
2666
+
description:
2667
+
'A cursor value to pass to subsequent calls to get the next page of results.',
2668
+
},
2669
+
},
2670
+
},
2671
+
},
2672
+
},
2673
+
},
2674
+
},
2675
+
AppRockskyGraphUnfollowAccount: {
2676
+
lexicon: 1,
2677
+
id: 'app.rocksky.graph.unfollowAccount',
2678
+
defs: {
2679
+
main: {
2680
+
type: 'procedure',
2681
+
description:
2682
+
"Removes a 'follow' relationship from the authenticated account to a specified account.",
2683
+
parameters: {
2684
+
type: 'params',
2685
+
required: ['account'],
2686
+
properties: {
2687
+
account: {
2688
+
type: 'string',
2689
+
format: 'at-identifier',
2690
+
},
2691
+
},
2692
+
},
2693
+
output: {
2694
+
encoding: 'application/json',
2695
+
schema: {
2696
+
type: 'object',
2697
+
required: ['subject', 'followers'],
2698
+
properties: {
2699
+
subject: {
2700
+
type: 'ref',
2701
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2702
+
},
2703
+
followers: {
2704
+
type: 'array',
2705
+
items: {
2706
+
type: 'ref',
2707
+
ref: 'lex:app.rocksky.actor.defs#profileViewBasic',
2708
+
},
2709
+
},
2710
+
cursor: {
2711
+
type: 'string',
2712
+
description:
2713
+
'A cursor value to pass to subsequent calls to get the next page of results.',
2714
+
},
2715
+
},
2716
+
},
2717
+
},
2718
+
},
2719
+
},
2720
+
},
2721
+
AppRockskyLikeDislikeShout: {
2722
+
lexicon: 1,
2723
+
id: 'app.rocksky.like.dislikeShout',
2724
+
defs: {
2725
+
main: {
2726
+
type: 'procedure',
2727
+
description: 'Dislike a shout',
2728
+
input: {
2729
+
encoding: 'application/json',
2730
+
schema: {
2731
+
type: 'object',
2732
+
properties: {
2733
+
uri: {
2734
+
type: 'string',
2735
+
description: 'The unique identifier of the shout to dislike',
2736
+
format: 'at-uri',
2737
+
},
2738
+
},
2739
+
},
2740
+
},
2741
+
output: {
2742
+
encoding: 'application/json',
2743
+
schema: {
2744
+
type: 'ref',
2745
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
2746
+
},
2747
+
},
2748
+
},
2749
+
},
2750
+
},
2751
+
AppRockskyLikeDislikeSong: {
2752
+
lexicon: 1,
2753
+
id: 'app.rocksky.like.dislikeSong',
2754
+
defs: {
2755
+
main: {
2756
+
type: 'procedure',
2757
+
description: 'Dislike a song',
2758
+
input: {
2759
+
encoding: 'application/json',
2760
+
schema: {
2761
+
type: 'object',
2762
+
properties: {
2763
+
uri: {
2764
+
type: 'string',
2765
+
description: 'The unique identifier of the song to dislike',
2766
+
format: 'at-uri',
2767
+
},
2768
+
},
2769
+
},
2770
+
},
2771
+
output: {
2772
+
encoding: 'application/json',
2773
+
schema: {
2774
+
type: 'ref',
2775
+
ref: 'lex:app.rocksky.song.defs#songViewDetailed',
2776
+
},
2777
+
},
2778
+
},
2779
+
},
2780
+
},
2781
+
AppRockskyLike: {
2782
+
lexicon: 1,
2783
+
id: 'app.rocksky.like',
2784
+
defs: {
2785
+
main: {
2786
+
type: 'record',
2787
+
description: 'A declaration of a like.',
2788
+
key: 'tid',
2789
+
record: {
2790
+
type: 'object',
2791
+
required: ['createdAt', 'subject'],
2792
+
properties: {
2793
+
createdAt: {
2794
+
type: 'string',
2795
+
description: 'The date when the like was created.',
2796
+
format: 'datetime',
2797
+
},
2798
+
subject: {
2799
+
type: 'ref',
2800
+
ref: 'lex:com.atproto.repo.strongRef',
2801
+
},
2802
+
},
2803
+
},
2804
+
},
2805
+
},
2806
+
},
2807
+
AppRockskyLikeLikeShout: {
2808
+
lexicon: 1,
2809
+
id: 'app.rocksky.like.likeShout',
2810
+
defs: {
2811
+
main: {
2812
+
type: 'procedure',
2813
+
description: 'Like a shout',
2814
+
input: {
2815
+
encoding: 'application/json',
2816
+
schema: {
2817
+
type: 'object',
2818
+
properties: {
2819
+
uri: {
2820
+
type: 'string',
2821
+
description: 'The unique identifier of the shout to like',
2822
+
format: 'at-uri',
2823
+
},
2824
+
},
2825
+
},
2826
+
},
2827
+
output: {
2828
+
encoding: 'application/json',
2829
+
schema: {
2830
+
type: 'ref',
2831
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
2832
+
},
2833
+
},
2834
+
},
2835
+
},
2836
+
},
2837
+
AppRockskyLikeLikeSong: {
2838
+
lexicon: 1,
2839
+
id: 'app.rocksky.like.likeSong',
2840
+
defs: {
2841
+
main: {
2842
+
type: 'procedure',
2843
+
description: 'Like a song',
2844
+
input: {
2845
+
encoding: 'application/json',
2846
+
schema: {
2847
+
type: 'object',
2848
+
properties: {
2849
+
uri: {
2850
+
type: 'string',
2851
+
description: 'The unique identifier of the song to like',
2852
+
format: 'at-uri',
2853
+
},
2854
+
},
2855
+
},
2856
+
},
2857
+
output: {
2858
+
encoding: 'application/json',
2859
+
schema: {
2860
+
type: 'ref',
2861
+
ref: 'lex:app.rocksky.song.defs#songViewDetailed',
2862
+
},
2863
+
},
2864
+
},
2865
+
},
2866
+
},
2867
+
AppRockskyPlayerAddDirectoryToQueue: {
2868
+
lexicon: 1,
2869
+
id: 'app.rocksky.player.addDirectoryToQueue',
2870
+
defs: {
2871
+
main: {
2872
+
type: 'procedure',
2873
+
description: "Add directory to the player's queue",
2874
+
parameters: {
2875
+
type: 'params',
2876
+
required: ['directory'],
2877
+
properties: {
2878
+
playerId: {
2879
+
type: 'string',
2880
+
},
2881
+
directory: {
2882
+
type: 'string',
2883
+
description: 'The directory to add to the queue',
2884
+
},
2885
+
position: {
2886
+
type: 'integer',
2887
+
description:
2888
+
'Position in the queue to insert the directory at, defaults to the end if not specified',
2889
+
},
2890
+
shuffle: {
2891
+
type: 'boolean',
2892
+
description:
2893
+
'Whether to shuffle the added directory in the queue',
2894
+
},
2895
+
},
2896
+
},
2897
+
},
2898
+
},
2899
+
},
2900
+
AppRockskyPlayerAddItemsToQueue: {
2901
+
lexicon: 1,
2902
+
id: 'app.rocksky.player.addItemsToQueue',
2903
+
defs: {
2904
+
main: {
2905
+
type: 'procedure',
2906
+
description: "Add items to the player's queue",
2907
+
parameters: {
2908
+
type: 'params',
2909
+
required: ['items'],
2910
+
properties: {
2911
+
playerId: {
2912
+
type: 'string',
2913
+
},
2914
+
items: {
2915
+
type: 'array',
2916
+
items: {
2917
+
type: 'string',
2918
+
description: 'List of file identifiers to add to the queue',
2919
+
},
2920
+
},
2921
+
position: {
2922
+
type: 'integer',
2923
+
description:
2924
+
'Position in the queue to insert the items at, defaults to the end if not specified',
2925
+
},
2926
+
shuffle: {
2927
+
type: 'boolean',
2928
+
description: 'Whether to shuffle the added items in the queue',
2929
+
},
2930
+
},
2931
+
},
2932
+
},
2933
+
},
2934
+
},
2935
+
AppRockskyPlayerDefs: {
2936
+
lexicon: 1,
2937
+
id: 'app.rocksky.player.defs',
2938
+
defs: {
2939
+
currentlyPlayingViewDetailed: {
2940
+
type: 'object',
2941
+
properties: {
2942
+
title: {
2943
+
type: 'string',
2944
+
description: 'The title of the currently playing track',
2945
+
},
2946
+
},
2947
+
},
2948
+
playbackQueueViewDetailed: {
2949
+
type: 'object',
2950
+
properties: {
2951
+
tracks: {
2952
+
type: 'array',
2953
+
items: {
2954
+
type: 'ref',
2955
+
ref: 'lex:app.rocksky.song.defs.songViewBasic',
2956
+
},
2957
+
},
2958
+
},
2959
+
},
2960
+
},
2961
+
},
2962
+
AppRockskyPlayerGetCurrentlyPlaying: {
2963
+
lexicon: 1,
2964
+
id: 'app.rocksky.player.getCurrentlyPlaying',
2965
+
defs: {
2966
+
main: {
2967
+
type: 'query',
2968
+
description: 'Get the currently playing track',
2969
+
parameters: {
2970
+
type: 'params',
2971
+
properties: {
2972
+
playerId: {
2973
+
type: 'string',
2974
+
},
2975
+
actor: {
2976
+
type: 'string',
2977
+
description:
2978
+
'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.',
2979
+
format: 'at-identifier',
2980
+
},
2981
+
},
2982
+
},
2983
+
output: {
2984
+
encoding: 'application/json',
2985
+
schema: {
2986
+
type: 'ref',
2987
+
ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed',
2988
+
},
2989
+
},
2990
+
},
2991
+
},
2992
+
},
2993
+
AppRockskyPlayerGetPlaybackQueue: {
2994
+
lexicon: 1,
2995
+
id: 'app.rocksky.player.getPlaybackQueue',
2996
+
defs: {
2997
+
main: {
2998
+
type: 'query',
2999
+
description: 'Retrieve the current playback queue',
3000
+
parameters: {
3001
+
type: 'params',
3002
+
properties: {
3003
+
playerId: {
3004
+
type: 'string',
3005
+
},
3006
+
},
3007
+
},
3008
+
output: {
3009
+
encoding: 'application/json',
3010
+
schema: {
3011
+
type: 'ref',
3012
+
ref: 'lex:app.rocksky.player.defs#playbackQueueViewDetailed',
3013
+
},
3014
+
},
3015
+
},
3016
+
},
3017
+
},
3018
+
AppRockskyPlayerNext: {
3019
+
lexicon: 1,
3020
+
id: 'app.rocksky.player.next',
3021
+
defs: {
3022
+
main: {
3023
+
type: 'procedure',
3024
+
description: 'Play the next track in the queue',
3025
+
parameters: {
3026
+
type: 'params',
3027
+
properties: {
3028
+
playerId: {
3029
+
type: 'string',
3030
+
},
3031
+
},
3032
+
},
3033
+
},
3034
+
},
3035
+
},
3036
+
AppRockskyPlayerPause: {
3037
+
lexicon: 1,
3038
+
id: 'app.rocksky.player.pause',
3039
+
defs: {
3040
+
main: {
3041
+
type: 'procedure',
3042
+
description: 'Pause the currently playing track',
3043
+
parameters: {
3044
+
type: 'params',
3045
+
properties: {
3046
+
playerId: {
3047
+
type: 'string',
3048
+
},
3049
+
},
3050
+
},
3051
+
},
3052
+
},
3053
+
},
3054
+
AppRockskyPlayerPlay: {
3055
+
lexicon: 1,
3056
+
id: 'app.rocksky.player.play',
3057
+
defs: {
3058
+
main: {
3059
+
type: 'procedure',
3060
+
description: 'Resume playback of the currently paused track',
3061
+
parameters: {
3062
+
type: 'params',
3063
+
properties: {
3064
+
playerId: {
3065
+
type: 'string',
3066
+
},
3067
+
},
3068
+
},
3069
+
},
3070
+
},
3071
+
},
3072
+
AppRockskyPlayerPlayDirectory: {
3073
+
lexicon: 1,
3074
+
id: 'app.rocksky.player.playDirectory',
3075
+
defs: {
3076
+
main: {
3077
+
type: 'procedure',
3078
+
description: 'Play all tracks in a directory',
3079
+
parameters: {
3080
+
type: 'params',
3081
+
required: ['directoryId'],
3082
+
properties: {
3083
+
playerId: {
3084
+
type: 'string',
3085
+
},
3086
+
directoryId: {
3087
+
type: 'string',
3088
+
},
3089
+
shuffle: {
3090
+
type: 'boolean',
3091
+
},
3092
+
recurse: {
3093
+
type: 'boolean',
3094
+
},
3095
+
position: {
3096
+
type: 'integer',
3097
+
},
3098
+
},
3099
+
},
3100
+
},
3101
+
},
3102
+
},
3103
+
AppRockskyPlayerPlayFile: {
3104
+
lexicon: 1,
3105
+
id: 'app.rocksky.player.playFile',
3106
+
defs: {
3107
+
main: {
3108
+
type: 'procedure',
3109
+
description: 'Play a specific audio file',
3110
+
parameters: {
3111
+
type: 'params',
3112
+
required: ['fileId'],
3113
+
properties: {
3114
+
playerId: {
3115
+
type: 'string',
3116
+
},
3117
+
fileId: {
3118
+
type: 'string',
3119
+
},
3120
+
},
3121
+
},
3122
+
},
3123
+
},
3124
+
},
3125
+
AppRockskyPlayerPrevious: {
3126
+
lexicon: 1,
3127
+
id: 'app.rocksky.player.previous',
3128
+
defs: {
3129
+
main: {
3130
+
type: 'procedure',
3131
+
description: 'Play the previous track in the queue',
3132
+
parameters: {
3133
+
type: 'params',
3134
+
properties: {
3135
+
playerId: {
3136
+
type: 'string',
3137
+
},
3138
+
},
3139
+
},
3140
+
},
3141
+
},
3142
+
},
3143
+
AppRockskyPlayerSeek: {
3144
+
lexicon: 1,
3145
+
id: 'app.rocksky.player.seek',
3146
+
defs: {
3147
+
main: {
3148
+
type: 'procedure',
3149
+
description:
3150
+
'Seek to a specific position in the currently playing track',
3151
+
parameters: {
3152
+
type: 'params',
3153
+
required: ['position'],
3154
+
properties: {
3155
+
playerId: {
3156
+
type: 'string',
3157
+
},
3158
+
position: {
3159
+
type: 'integer',
3160
+
description: 'The position in seconds to seek to',
3161
+
},
3162
+
},
3163
+
},
3164
+
},
3165
+
},
3166
+
},
3167
+
AppRockskyPlaylistCreatePlaylist: {
3168
+
lexicon: 1,
3169
+
id: 'app.rocksky.playlist.createPlaylist',
3170
+
defs: {
3171
+
main: {
3172
+
type: 'procedure',
3173
+
description: 'Create a new playlist',
3174
+
parameters: {
3175
+
type: 'params',
3176
+
required: ['name'],
3177
+
properties: {
3178
+
name: {
3179
+
type: 'string',
3180
+
description: 'The name of the playlist',
3181
+
},
3182
+
description: {
3183
+
type: 'string',
3184
+
description: 'A brief description of the playlist',
3185
+
},
3186
+
},
3187
+
},
3188
+
},
3189
+
},
3190
+
},
3191
+
AppRockskyPlaylistDefs: {
3192
+
lexicon: 1,
3193
+
id: 'app.rocksky.playlist.defs',
3194
+
defs: {
3195
+
playlistViewDetailed: {
3196
+
type: 'object',
3197
+
description:
3198
+
'Detailed view of a playlist, including its tracks and metadata',
3199
+
properties: {
3200
+
id: {
3201
+
type: 'string',
3202
+
description: 'The unique identifier of the playlist.',
3203
+
},
3204
+
title: {
3205
+
type: 'string',
3206
+
description: 'The title of the playlist.',
3207
+
},
3208
+
uri: {
3209
+
type: 'string',
3210
+
description: 'The URI of the playlist.',
3211
+
format: 'at-uri',
3212
+
},
3213
+
curatorDid: {
3214
+
type: 'string',
3215
+
description: 'The DID of the curator of the playlist.',
3216
+
format: 'at-identifier',
3217
+
},
3218
+
curatorHandle: {
3219
+
type: 'string',
3220
+
description: 'The handle of the curator of the playlist.',
3221
+
format: 'at-identifier',
3222
+
},
3223
+
curatorName: {
3224
+
type: 'string',
3225
+
description: 'The name of the curator of the playlist.',
3226
+
},
3227
+
curatorAvatarUrl: {
3228
+
type: 'string',
3229
+
description: 'The URL of the avatar image of the curator.',
3230
+
format: 'uri',
3231
+
},
3232
+
description: {
3233
+
type: 'string',
3234
+
description: 'A description of the playlist.',
3235
+
},
3236
+
coverImageUrl: {
3237
+
type: 'string',
3238
+
description: 'The URL of the cover image for the playlist.',
3239
+
format: 'uri',
3240
+
},
3241
+
createdAt: {
3242
+
type: 'string',
3243
+
description: 'The date and time when the playlist was created.',
3244
+
format: 'datetime',
3245
+
},
3246
+
tracks: {
3247
+
type: 'array',
3248
+
description: 'A list of tracks in the playlist.',
3249
+
items: {
3250
+
type: 'ref',
3251
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
3252
+
},
3253
+
},
3254
+
},
3255
+
},
3256
+
playlistViewBasic: {
3257
+
type: 'object',
3258
+
description: 'Basic view of a playlist, including its metadata',
3259
+
properties: {
3260
+
id: {
3261
+
type: 'string',
3262
+
description: 'The unique identifier of the playlist.',
3263
+
},
3264
+
title: {
3265
+
type: 'string',
3266
+
description: 'The title of the playlist.',
3267
+
},
3268
+
uri: {
3269
+
type: 'string',
3270
+
description: 'The URI of the playlist.',
3271
+
format: 'at-uri',
3272
+
},
3273
+
curatorDid: {
3274
+
type: 'string',
3275
+
description: 'The DID of the curator of the playlist.',
3276
+
format: 'at-identifier',
3277
+
},
3278
+
curatorHandle: {
3279
+
type: 'string',
3280
+
description: 'The handle of the curator of the playlist.',
3281
+
format: 'at-identifier',
3282
+
},
3283
+
curatorName: {
3284
+
type: 'string',
3285
+
description: 'The name of the curator of the playlist.',
3286
+
},
3287
+
curatorAvatarUrl: {
3288
+
type: 'string',
3289
+
description: 'The URL of the avatar image of the curator.',
3290
+
format: 'uri',
3291
+
},
3292
+
description: {
3293
+
type: 'string',
3294
+
description: 'A description of the playlist.',
3295
+
},
3296
+
coverImageUrl: {
3297
+
type: 'string',
3298
+
description: 'The URL of the cover image for the playlist.',
3299
+
format: 'uri',
3300
+
},
3301
+
createdAt: {
3302
+
type: 'string',
3303
+
description: 'The date and time when the playlist was created.',
3304
+
format: 'datetime',
3305
+
},
3306
+
trackCount: {
3307
+
type: 'integer',
3308
+
description: 'The number of tracks in the playlist.',
3309
+
minimum: 0,
3310
+
},
3311
+
},
3312
+
},
3313
+
},
3314
+
},
3315
+
AppRockskyPlaylistGetPlaylist: {
3316
+
lexicon: 1,
3317
+
id: 'app.rocksky.playlist.getPlaylist',
3318
+
defs: {
3319
+
main: {
3320
+
type: 'query',
3321
+
description: 'Retrieve a playlist by its ID',
3322
+
parameters: {
3323
+
type: 'params',
3324
+
required: ['uri'],
3325
+
properties: {
3326
+
uri: {
3327
+
type: 'string',
3328
+
description: 'The URI of the playlist to retrieve.',
3329
+
format: 'at-uri',
3330
+
},
3331
+
},
3332
+
},
3333
+
output: {
3334
+
encoding: 'application/json',
3335
+
schema: {
3336
+
type: 'ref',
3337
+
ref: 'lex:app.rocksky.playlist.defs#playlistViewDetailed',
3338
+
},
3339
+
},
3340
+
},
3341
+
},
3342
+
},
3343
+
AppRockskyPlaylistGetPlaylists: {
3344
+
lexicon: 1,
3345
+
id: 'app.rocksky.playlist.getPlaylists',
3346
+
defs: {
3347
+
main: {
3348
+
type: 'query',
3349
+
description: 'Retrieve a list of playlists',
3350
+
parameters: {
3351
+
type: 'params',
3352
+
properties: {
3353
+
limit: {
3354
+
type: 'integer',
3355
+
description: 'The maximum number of playlists to return.',
3356
+
},
3357
+
offset: {
3358
+
type: 'integer',
3359
+
description:
3360
+
'The offset for pagination, used to skip a number of playlists.',
3361
+
},
3362
+
},
3363
+
},
3364
+
output: {
3365
+
encoding: 'application/json',
3366
+
schema: {
3367
+
type: 'object',
3368
+
properties: {
3369
+
playlists: {
3370
+
type: 'array',
3371
+
items: {
3372
+
type: 'ref',
3373
+
ref: 'lex:app.rocksky.playlist.defs#playlistViewBasic',
3374
+
},
3375
+
},
3376
+
},
3377
+
},
3378
+
},
3379
+
},
3380
+
},
3381
+
},
3382
+
AppRockskyPlaylistInsertDirectory: {
3383
+
lexicon: 1,
3384
+
id: 'app.rocksky.playlist.insertDirectory',
3385
+
defs: {
3386
+
main: {
3387
+
type: 'procedure',
3388
+
description: 'Insert a directory into a playlist',
3389
+
parameters: {
3390
+
type: 'params',
3391
+
required: ['uri', 'directory'],
3392
+
properties: {
3393
+
uri: {
3394
+
type: 'string',
3395
+
description: 'The URI of the playlist to start',
3396
+
format: 'at-uri',
3397
+
},
3398
+
directory: {
3399
+
type: 'string',
3400
+
description: 'The directory (id) to insert into the playlist',
3401
+
},
3402
+
position: {
3403
+
type: 'integer',
3404
+
description:
3405
+
'The position in the playlist to insert the directory at, if not specified, the directory will be appended',
3406
+
},
3407
+
},
3408
+
},
3409
+
},
3410
+
},
3411
+
},
3412
+
AppRockskyPlaylistInsertFiles: {
3413
+
lexicon: 1,
3414
+
id: 'app.rocksky.playlist.insertFiles',
3415
+
defs: {
3416
+
main: {
3417
+
type: 'procedure',
3418
+
description: 'Insert files into a playlist',
3419
+
parameters: {
3420
+
type: 'params',
3421
+
required: ['uri', 'files'],
3422
+
properties: {
3423
+
uri: {
3424
+
type: 'string',
3425
+
description: 'The URI of the playlist to start',
3426
+
format: 'at-uri',
3427
+
},
3428
+
files: {
3429
+
type: 'array',
3430
+
items: {
3431
+
type: 'string',
3432
+
description: 'List of file (id) to insert into the playlist',
3433
+
},
3434
+
},
3435
+
position: {
3436
+
type: 'integer',
3437
+
description:
3438
+
'The position in the playlist to insert the files at, if not specified, files will be appended',
3439
+
},
3440
+
},
3441
+
},
3442
+
},
3443
+
},
3444
+
},
3445
+
AppRockskyPlaylist: {
3446
+
lexicon: 1,
3447
+
id: 'app.rocksky.playlist',
3448
+
defs: {
3449
+
main: {
3450
+
type: 'record',
3451
+
description: 'A declaration of a playlist.',
3452
+
key: 'tid',
3453
+
record: {
3454
+
type: 'object',
3455
+
required: ['name', 'createdAt'],
3456
+
properties: {
3457
+
name: {
3458
+
type: 'string',
3459
+
description: 'The name of the playlist.',
3460
+
minLength: 1,
3461
+
maxLength: 512,
3462
+
},
3463
+
description: {
3464
+
type: 'string',
3465
+
description: 'The playlist description.',
3466
+
minLength: 1,
3467
+
maxLength: 256,
3468
+
},
3469
+
picture: {
3470
+
type: 'blob',
3471
+
description: 'The picture of the playlist.',
3472
+
accept: ['image/png', 'image/jpeg'],
3473
+
maxSize: 2000000,
3474
+
},
3475
+
tracks: {
3476
+
type: 'array',
3477
+
description: 'The tracks in the playlist.',
3478
+
items: {
3479
+
type: 'ref',
3480
+
ref: 'lex:app.rocksky.song#record',
3481
+
},
3482
+
},
3483
+
createdAt: {
3484
+
type: 'string',
3485
+
description: 'The date the playlist was created.',
3486
+
format: 'datetime',
3487
+
},
3488
+
spotifyLink: {
3489
+
type: 'string',
3490
+
description: 'The Spotify link of the playlist.',
3491
+
},
3492
+
tidalLink: {
3493
+
type: 'string',
3494
+
description: 'The Tidal link of the playlist.',
3495
+
},
3496
+
youtubeLink: {
3497
+
type: 'string',
3498
+
description: 'The YouTube link of the playlist.',
3499
+
},
3500
+
appleMusicLink: {
3501
+
type: 'string',
3502
+
description: 'The Apple Music link of the playlist.',
3503
+
},
3504
+
},
3505
+
},
3506
+
},
3507
+
},
3508
+
},
3509
+
AppRockskyPlaylistRemovePlaylist: {
3510
+
lexicon: 1,
3511
+
id: 'app.rocksky.playlist.removePlaylist',
3512
+
defs: {
3513
+
main: {
3514
+
type: 'procedure',
3515
+
description: 'Remove a playlist',
3516
+
parameters: {
3517
+
type: 'params',
3518
+
required: ['uri'],
3519
+
properties: {
3520
+
uri: {
3521
+
type: 'string',
3522
+
description: 'The URI of the playlist to remove',
3523
+
format: 'at-uri',
3524
+
},
3525
+
},
3526
+
},
3527
+
},
3528
+
},
3529
+
},
3530
+
AppRockskyPlaylistRemoveTrack: {
3531
+
lexicon: 1,
3532
+
id: 'app.rocksky.playlist.removeTrack',
3533
+
defs: {
3534
+
main: {
3535
+
type: 'procedure',
3536
+
description: 'Remove a track from a playlist',
3537
+
parameters: {
3538
+
type: 'params',
3539
+
required: ['uri', 'position'],
3540
+
properties: {
3541
+
uri: {
3542
+
type: 'string',
3543
+
description: 'The URI of the playlist to remove the track from',
3544
+
format: 'at-uri',
3545
+
},
3546
+
position: {
3547
+
type: 'integer',
3548
+
description:
3549
+
'The position of the track to remove in the playlist',
3550
+
},
3551
+
},
3552
+
},
3553
+
},
3554
+
},
3555
+
},
3556
+
AppRockskyPlaylistStartPlaylist: {
3557
+
lexicon: 1,
3558
+
id: 'app.rocksky.playlist.startPlaylist',
3559
+
defs: {
3560
+
main: {
3561
+
type: 'procedure',
3562
+
description: 'Start a playlist',
3563
+
parameters: {
3564
+
type: 'params',
3565
+
required: ['uri'],
3566
+
properties: {
3567
+
uri: {
3568
+
type: 'string',
3569
+
description: 'The URI of the playlist to start',
3570
+
format: 'at-uri',
3571
+
},
3572
+
shuffle: {
3573
+
type: 'boolean',
3574
+
description: 'Whether to shuffle the playlist when starting it',
3575
+
},
3576
+
position: {
3577
+
type: 'integer',
3578
+
description:
3579
+
'The position in the playlist to start from, if not specified, starts from the beginning',
3580
+
},
3581
+
},
3582
+
},
3583
+
},
3584
+
},
3585
+
},
3586
+
AppRockskyRadioDefs: {
3587
+
lexicon: 1,
3588
+
id: 'app.rocksky.radio.defs',
3589
+
defs: {
3590
+
radioViewBasic: {
3591
+
type: 'object',
3592
+
properties: {
3593
+
id: {
3594
+
type: 'string',
3595
+
description: 'The unique identifier of the radio.',
3596
+
},
3597
+
name: {
3598
+
type: 'string',
3599
+
description: 'The name of the radio.',
3600
+
},
3601
+
description: {
3602
+
type: 'string',
3603
+
description: 'A brief description of the radio.',
3604
+
},
3605
+
createdAt: {
3606
+
type: 'string',
3607
+
description: 'The date and time when the radio was created.',
3608
+
format: 'datetime',
3609
+
},
3610
+
},
3611
+
},
3612
+
radioViewDetailed: {
3613
+
type: 'object',
3614
+
properties: {
3615
+
id: {
3616
+
type: 'string',
3617
+
description: 'The unique identifier of the radio.',
3618
+
},
3619
+
name: {
3620
+
type: 'string',
3621
+
description: 'The name of the radio.',
3622
+
},
3623
+
description: {
3624
+
type: 'string',
3625
+
description: 'A brief description of the radio.',
3626
+
},
3627
+
website: {
3628
+
type: 'string',
3629
+
description: 'The website of the radio.',
3630
+
format: 'uri',
3631
+
},
3632
+
url: {
3633
+
type: 'string',
3634
+
description: 'The streaming URL of the radio.',
3635
+
format: 'uri',
3636
+
},
3637
+
genre: {
3638
+
type: 'string',
3639
+
description: 'The genre of the radio.',
3640
+
},
3641
+
logo: {
3642
+
type: 'string',
3643
+
description: 'The logo of the radio station.',
3644
+
},
3645
+
createdAt: {
3646
+
type: 'string',
3647
+
description: 'The date and time when the radio was created.',
3648
+
format: 'datetime',
3649
+
},
3650
+
},
3651
+
},
3652
+
},
3653
+
},
3654
+
AppRockskyRadio: {
3655
+
lexicon: 1,
3656
+
id: 'app.rocksky.radio',
3657
+
defs: {
3658
+
main: {
3659
+
type: 'record',
3660
+
description: 'A declaration of a radio station.',
3661
+
key: 'tid',
3662
+
record: {
3663
+
type: 'object',
3664
+
required: ['name', 'url', 'createdAt'],
3665
+
properties: {
3666
+
name: {
3667
+
type: 'string',
3668
+
description: 'The name of the radio station.',
3669
+
minLength: 1,
3670
+
maxLength: 512,
3671
+
},
3672
+
url: {
3673
+
type: 'string',
3674
+
description: 'The URL of the radio station.',
3675
+
format: 'uri',
3676
+
},
3677
+
description: {
3678
+
type: 'string',
3679
+
description: 'A description of the radio station.',
3680
+
minLength: 1,
3681
+
maxLength: 1000,
3682
+
},
3683
+
genre: {
3684
+
type: 'string',
3685
+
description: 'The genre of the radio station.',
3686
+
minLength: 1,
3687
+
maxLength: 256,
3688
+
},
3689
+
logo: {
3690
+
type: 'blob',
3691
+
description: 'The logo of the radio station.',
3692
+
accept: ['image/png', 'image/jpeg'],
3693
+
maxSize: 2000000,
3694
+
},
3695
+
website: {
3696
+
type: 'string',
3697
+
description: 'The website of the radio station.',
3698
+
format: 'uri',
3699
+
},
3700
+
createdAt: {
3701
+
type: 'string',
3702
+
description: 'The date when the radio station was created.',
3703
+
format: 'datetime',
3704
+
},
3705
+
},
3706
+
},
3707
+
},
3708
+
},
3709
+
},
3710
+
AppRockskyScrobbleCreateScrobble: {
3711
+
lexicon: 1,
3712
+
id: 'app.rocksky.scrobble.createScrobble',
3713
+
defs: {
3714
+
main: {
3715
+
type: 'procedure',
3716
+
description: 'Create a new scrobble',
3717
+
input: {
3718
+
encoding: 'application/json',
3719
+
schema: {
3720
+
type: 'object',
3721
+
required: ['title', 'artist'],
3722
+
properties: {
3723
+
title: {
3724
+
type: 'string',
3725
+
description: 'The title of the track being scrobbled',
3726
+
},
3727
+
artist: {
3728
+
type: 'string',
3729
+
description: 'The artist of the track being scrobbled',
3730
+
},
3731
+
album: {
3732
+
type: 'string',
3733
+
description: 'The album of the track being scrobbled',
3734
+
},
3735
+
duration: {
3736
+
type: 'integer',
3737
+
description: 'The duration of the track in seconds',
3738
+
},
3739
+
mbId: {
3740
+
type: 'string',
3741
+
description: 'The MusicBrainz ID of the track, if available',
3742
+
},
3743
+
albumArt: {
3744
+
type: 'string',
3745
+
description: 'The URL of the album art for the track',
3746
+
format: 'uri',
3747
+
},
3748
+
trackNumber: {
3749
+
type: 'integer',
3750
+
description: 'The track number of the track in the album',
3751
+
},
3752
+
releaseDate: {
3753
+
type: 'string',
3754
+
description:
3755
+
'The release date of the track, formatted as YYYY-MM-DD',
3756
+
},
3757
+
year: {
3758
+
type: 'integer',
3759
+
description: 'The year the track was released',
3760
+
},
3761
+
discNumber: {
3762
+
type: 'integer',
3763
+
description:
3764
+
'The disc number of the track in the album, if applicable',
3765
+
},
3766
+
lyrics: {
3767
+
type: 'string',
3768
+
description: 'The lyrics of the track, if available',
3769
+
},
3770
+
composer: {
3771
+
type: 'string',
3772
+
description: 'The composer of the track, if available',
3773
+
},
3774
+
copyrightMessage: {
3775
+
type: 'string',
3776
+
description:
3777
+
'The copyright message for the track, if available',
3778
+
},
3779
+
label: {
3780
+
type: 'string',
3781
+
description: 'The record label of the track, if available',
3782
+
},
3783
+
artistPicture: {
3784
+
type: 'string',
3785
+
description: "The URL of the artist's picture, if available",
3786
+
format: 'uri',
3787
+
},
3788
+
spotifyLink: {
3789
+
type: 'string',
3790
+
description: 'The Spotify link for the track, if available',
3791
+
format: 'uri',
3792
+
},
3793
+
lastfmLink: {
3794
+
type: 'string',
3795
+
description: 'The Last.fm link for the track, if available',
3796
+
format: 'uri',
3797
+
},
3798
+
tidalLink: {
3799
+
type: 'string',
3800
+
description: 'The Tidal link for the track, if available',
3801
+
format: 'uri',
3802
+
},
3803
+
appleMusicLink: {
3804
+
type: 'string',
3805
+
description: 'The Apple Music link for the track, if available',
3806
+
format: 'uri',
3807
+
},
3808
+
youtubeLink: {
3809
+
type: 'string',
3810
+
description: 'The Youtube link for the track, if available',
3811
+
format: 'uri',
3812
+
},
3813
+
deezerLink: {
3814
+
type: 'string',
3815
+
description: 'The Deezer link for the track, if available',
3816
+
format: 'uri',
3817
+
},
3818
+
timestamp: {
3819
+
type: 'integer',
3820
+
description:
3821
+
'The timestamp of the scrobble in milliseconds since epoch',
3822
+
},
3823
+
},
3824
+
},
3825
+
},
3826
+
output: {
3827
+
encoding: 'application/json',
3828
+
schema: {
3829
+
type: 'ref',
3830
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
3831
+
},
3832
+
},
3833
+
},
3834
+
},
3835
+
},
3836
+
AppRockskyScrobbleDefs: {
3837
+
lexicon: 1,
3838
+
id: 'app.rocksky.scrobble.defs',
3839
+
defs: {
3840
+
scrobbleViewBasic: {
3841
+
type: 'object',
3842
+
properties: {
3843
+
id: {
3844
+
type: 'string',
3845
+
description: 'The unique identifier of the scrobble.',
3846
+
},
3847
+
user: {
3848
+
type: 'string',
3849
+
description: 'The handle of the user who created the scrobble.',
3850
+
},
3851
+
userDisplayName: {
3852
+
type: 'string',
3853
+
description:
3854
+
'The display name of the user who created the scrobble.',
3855
+
},
3856
+
userAvatar: {
3857
+
type: 'string',
3858
+
description: 'The avatar URL of the user who created the scrobble.',
3859
+
format: 'uri',
3860
+
},
3861
+
title: {
3862
+
type: 'string',
3863
+
description: 'The title of the scrobble.',
3864
+
},
3865
+
artist: {
3866
+
type: 'string',
3867
+
description: 'The artist of the song.',
3868
+
},
3869
+
artistUri: {
3870
+
type: 'string',
3871
+
description: 'The URI of the artist.',
3872
+
format: 'at-uri',
3873
+
},
3874
+
album: {
3875
+
type: 'string',
3876
+
description: 'The album of the song.',
3877
+
},
3878
+
albumUri: {
3879
+
type: 'string',
3880
+
description: 'The URI of the album.',
3881
+
format: 'at-uri',
3882
+
},
3883
+
cover: {
3884
+
type: 'string',
3885
+
description: 'The album art URL of the song.',
3886
+
format: 'uri',
3887
+
},
3888
+
date: {
3889
+
type: 'string',
3890
+
description: 'The timestamp when the scrobble was created.',
3891
+
format: 'datetime',
3892
+
},
3893
+
uri: {
3894
+
type: 'string',
3895
+
description: 'The URI of the scrobble.',
3896
+
format: 'uri',
3897
+
},
3898
+
sha256: {
3899
+
type: 'string',
3900
+
description: 'The SHA256 hash of the scrobble data.',
3901
+
},
3902
+
liked: {
3903
+
type: 'boolean',
3904
+
},
3905
+
likesCount: {
3906
+
type: 'integer',
3907
+
},
3908
+
},
3909
+
},
3910
+
scrobbleViewDetailed: {
3911
+
type: 'object',
3912
+
properties: {
3913
+
id: {
3914
+
type: 'string',
3915
+
description: 'The unique identifier of the scrobble.',
3916
+
},
3917
+
user: {
3918
+
type: 'string',
3919
+
description: 'The handle of the user who created the scrobble.',
3920
+
},
3921
+
title: {
3922
+
type: 'string',
3923
+
description: 'The title of the scrobble.',
3924
+
},
3925
+
artist: {
3926
+
type: 'string',
3927
+
description: 'The artist of the song.',
3928
+
},
3929
+
artistUri: {
3930
+
type: 'string',
3931
+
description: 'The URI of the artist.',
3932
+
format: 'at-uri',
3933
+
},
3934
+
album: {
3935
+
type: 'string',
3936
+
description: 'The album of the song.',
3937
+
},
3938
+
albumUri: {
3939
+
type: 'string',
3940
+
description: 'The URI of the album.',
3941
+
format: 'at-uri',
3942
+
},
3943
+
cover: {
3944
+
type: 'string',
3945
+
description: 'The album art URL of the song.',
3946
+
format: 'uri',
3947
+
},
3948
+
date: {
3949
+
type: 'string',
3950
+
description: 'The timestamp when the scrobble was created.',
3951
+
format: 'datetime',
3952
+
},
3953
+
uri: {
3954
+
type: 'string',
3955
+
description: 'The URI of the scrobble.',
3956
+
format: 'uri',
3957
+
},
3958
+
sha256: {
3959
+
type: 'string',
3960
+
description: 'The SHA256 hash of the scrobble data.',
3961
+
},
3962
+
listeners: {
3963
+
type: 'integer',
3964
+
description: 'The number of listeners',
3965
+
},
3966
+
scrobbles: {
3967
+
type: 'integer',
3968
+
description: 'The number of scrobbles for this song',
3969
+
},
3970
+
},
3971
+
},
3972
+
},
3973
+
},
3974
+
AppRockskyScrobbleGetScrobble: {
3975
+
lexicon: 1,
3976
+
id: 'app.rocksky.scrobble.getScrobble',
3977
+
defs: {
3978
+
main: {
3979
+
type: 'query',
3980
+
description: 'Get a scrobble by its unique identifier',
3981
+
parameters: {
3982
+
type: 'params',
3983
+
required: ['uri'],
3984
+
properties: {
3985
+
uri: {
3986
+
type: 'string',
3987
+
description: 'The unique identifier of the scrobble',
3988
+
format: 'at-uri',
3989
+
},
3990
+
},
3991
+
},
3992
+
output: {
3993
+
encoding: 'application/json',
3994
+
schema: {
3995
+
type: 'ref',
3996
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewDetailed',
3997
+
},
3998
+
},
3999
+
},
4000
+
},
4001
+
},
4002
+
AppRockskyScrobbleGetScrobbles: {
4003
+
lexicon: 1,
4004
+
id: 'app.rocksky.scrobble.getScrobbles',
4005
+
defs: {
4006
+
main: {
4007
+
type: 'query',
4008
+
description: 'Get scrobbles all scrobbles',
4009
+
parameters: {
4010
+
type: 'params',
4011
+
properties: {
4012
+
did: {
4013
+
type: 'string',
4014
+
description: 'The DID or handle of the actor',
4015
+
format: 'at-identifier',
4016
+
},
4017
+
following: {
4018
+
type: 'boolean',
4019
+
description:
4020
+
'If true, only return scrobbles from actors the viewer is following.',
4021
+
},
4022
+
limit: {
4023
+
type: 'integer',
4024
+
description: 'The maximum number of scrobbles to return',
4025
+
minimum: 1,
4026
+
},
4027
+
offset: {
4028
+
type: 'integer',
4029
+
description: 'The offset for pagination',
4030
+
minimum: 0,
4031
+
},
4032
+
},
4033
+
},
4034
+
output: {
4035
+
encoding: 'application/json',
4036
+
schema: {
4037
+
type: 'object',
4038
+
properties: {
4039
+
scrobbles: {
4040
+
type: 'array',
4041
+
items: {
4042
+
type: 'ref',
4043
+
ref: 'lex:app.rocksky.scrobble.defs#scrobbleViewBasic',
4044
+
},
4045
+
},
4046
+
},
4047
+
},
4048
+
},
4049
+
},
4050
+
},
4051
+
},
4052
+
AppRockskyScrobble: {
4053
+
lexicon: 1,
4054
+
id: 'app.rocksky.scrobble',
4055
+
defs: {
4056
+
main: {
4057
+
type: 'record',
4058
+
description: 'A declaration of a scrobble.',
4059
+
key: 'tid',
4060
+
record: {
4061
+
type: 'object',
4062
+
required: [
4063
+
'title',
4064
+
'artist',
4065
+
'album',
4066
+
'albumArtist',
4067
+
'duration',
4068
+
'createdAt',
4069
+
],
4070
+
properties: {
4071
+
title: {
4072
+
type: 'string',
4073
+
description: 'The title of the song.',
4074
+
minLength: 1,
4075
+
maxLength: 512,
4076
+
},
4077
+
artist: {
4078
+
type: 'string',
4079
+
description: 'The artist of the song.',
4080
+
minLength: 1,
4081
+
maxLength: 256,
4082
+
},
4083
+
artists: {
4084
+
type: 'array',
4085
+
description: 'The artists of the song with MusicBrainz IDs.',
4086
+
items: {
4087
+
type: 'ref',
4088
+
ref: 'lex:app.rocksky.artist.defs#artistMbid',
4089
+
},
4090
+
},
4091
+
albumArtist: {
4092
+
type: 'string',
4093
+
description: 'The album artist of the song.',
4094
+
minLength: 1,
4095
+
maxLength: 256,
4096
+
},
4097
+
album: {
4098
+
type: 'string',
4099
+
description: 'The album of the song.',
4100
+
minLength: 1,
4101
+
maxLength: 256,
4102
+
},
4103
+
duration: {
4104
+
type: 'integer',
4105
+
description: 'The duration of the song in seconds.',
4106
+
minimum: 1,
4107
+
},
4108
+
trackNumber: {
4109
+
type: 'integer',
4110
+
description: 'The track number of the song in the album.',
4111
+
minimum: 1,
4112
+
},
4113
+
discNumber: {
4114
+
type: 'integer',
4115
+
description: 'The disc number of the song in the album.',
4116
+
minimum: 1,
4117
+
},
4118
+
releaseDate: {
4119
+
type: 'string',
4120
+
description: 'The release date of the song.',
4121
+
format: 'datetime',
4122
+
},
4123
+
year: {
4124
+
type: 'integer',
4125
+
description: 'The year the song was released.',
4126
+
},
4127
+
genre: {
4128
+
type: 'string',
4129
+
description: 'The genre of the song.',
4130
+
maxLength: 256,
4131
+
},
4132
+
tags: {
4133
+
type: 'array',
4134
+
description: 'The tags of the song.',
4135
+
items: {
4136
+
type: 'string',
4137
+
minLength: 1,
4138
+
maxLength: 256,
4139
+
},
4140
+
},
4141
+
composer: {
4142
+
type: 'string',
4143
+
description: 'The composer of the song.',
4144
+
maxLength: 256,
4145
+
},
4146
+
lyrics: {
4147
+
type: 'string',
4148
+
description: 'The lyrics of the song.',
4149
+
maxLength: 10000,
4150
+
},
4151
+
copyrightMessage: {
4152
+
type: 'string',
4153
+
description: 'The copyright message of the song.',
4154
+
maxLength: 256,
4155
+
},
4156
+
wiki: {
4157
+
type: 'string',
4158
+
description: 'Informations about the song',
4159
+
maxLength: 10000,
4160
+
},
4161
+
albumArt: {
4162
+
type: 'blob',
4163
+
description: 'The album art of the song.',
4164
+
accept: ['image/png', 'image/jpeg'],
4165
+
maxSize: 2000000,
4166
+
},
4167
+
albumArtUrl: {
4168
+
type: 'string',
4169
+
description: 'The URL of the album art of the song.',
4170
+
format: 'uri',
4171
+
},
4172
+
youtubeLink: {
4173
+
type: 'string',
4174
+
description: 'The YouTube link of the song.',
4175
+
format: 'uri',
4176
+
},
4177
+
spotifyLink: {
4178
+
type: 'string',
4179
+
description: 'The Spotify link of the song.',
4180
+
format: 'uri',
4181
+
},
4182
+
tidalLink: {
4183
+
type: 'string',
4184
+
description: 'The Tidal link of the song.',
4185
+
format: 'uri',
4186
+
},
4187
+
appleMusicLink: {
4188
+
type: 'string',
4189
+
description: 'The Apple Music link of the song.',
4190
+
format: 'uri',
4191
+
},
4192
+
createdAt: {
4193
+
type: 'string',
4194
+
description: 'The date when the song was created.',
4195
+
format: 'datetime',
4196
+
},
4197
+
mbid: {
4198
+
type: 'string',
4199
+
description: 'The MusicBrainz ID of the song.',
4200
+
},
4201
+
label: {
4202
+
type: 'string',
4203
+
description: 'The label of the song.',
4204
+
maxLength: 256,
4205
+
},
4206
+
},
4207
+
},
4208
+
},
4209
+
},
4210
+
},
4211
+
AppRockskyShoutCreateShout: {
4212
+
lexicon: 1,
4213
+
id: 'app.rocksky.shout.createShout',
4214
+
defs: {
4215
+
main: {
4216
+
type: 'procedure',
4217
+
description: 'Create a new shout',
4218
+
input: {
4219
+
encoding: 'application/json',
4220
+
schema: {
4221
+
type: 'object',
4222
+
properties: {
4223
+
message: {
4224
+
type: 'string',
4225
+
description: 'The content of the shout',
4226
+
minLength: 1,
4227
+
},
4228
+
},
4229
+
},
4230
+
},
4231
+
output: {
4232
+
encoding: 'application/json',
4233
+
schema: {
4234
+
type: 'ref',
4235
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
4236
+
},
4237
+
},
4238
+
},
4239
+
},
4240
+
},
4241
+
AppRockskyShoutDefs: {
4242
+
lexicon: 1,
4243
+
id: 'app.rocksky.shout.defs',
4244
+
defs: {
4245
+
author: {
4246
+
type: 'object',
4247
+
properties: {
4248
+
id: {
4249
+
type: 'string',
4250
+
description: 'The unique identifier of the author.',
4251
+
},
4252
+
did: {
4253
+
type: 'string',
4254
+
description: 'The decentralized identifier (DID) of the author.',
4255
+
format: 'at-identifier',
4256
+
},
4257
+
handle: {
4258
+
type: 'string',
4259
+
description: 'The handle of the author.',
4260
+
format: 'at-identifier',
4261
+
},
4262
+
displayName: {
4263
+
type: 'string',
4264
+
description: 'The display name of the author.',
4265
+
},
4266
+
avatar: {
4267
+
type: 'string',
4268
+
description: "The URL of the author's avatar image.",
4269
+
format: 'uri',
4270
+
},
4271
+
},
4272
+
},
4273
+
shoutView: {
4274
+
type: 'object',
4275
+
properties: {
4276
+
id: {
4277
+
type: 'string',
4278
+
description: 'The unique identifier of the shout.',
4279
+
},
4280
+
message: {
4281
+
type: 'string',
4282
+
description: 'The content of the shout.',
4283
+
},
4284
+
parent: {
4285
+
type: 'string',
4286
+
description:
4287
+
'The ID of the parent shout if this is a reply, otherwise null.',
4288
+
},
4289
+
createdAt: {
4290
+
type: 'string',
4291
+
description: 'The date and time when the shout was created.',
4292
+
format: 'datetime',
4293
+
},
4294
+
author: {
4295
+
type: 'ref',
4296
+
description: 'The author of the shout.',
4297
+
ref: 'lex:app.rocksky.shout.defs#author',
4298
+
},
4299
+
},
4300
+
},
4301
+
},
4302
+
},
4303
+
AppRockskyShoutGetAlbumShouts: {
4304
+
lexicon: 1,
4305
+
id: 'app.rocksky.shout.getAlbumShouts',
4306
+
defs: {
4307
+
main: {
4308
+
type: 'query',
4309
+
description: 'Get shouts for an album',
4310
+
parameters: {
4311
+
type: 'params',
4312
+
required: ['uri'],
4313
+
properties: {
4314
+
uri: {
4315
+
type: 'string',
4316
+
description:
4317
+
'The unique identifier of the album to retrieve shouts for',
4318
+
format: 'at-uri',
4319
+
},
4320
+
limit: {
4321
+
type: 'integer',
4322
+
description: 'The maximum number of shouts to return',
4323
+
minimum: 1,
4324
+
},
4325
+
offset: {
4326
+
type: 'integer',
4327
+
description:
4328
+
'The number of shouts to skip before starting to collect the result set',
4329
+
minimum: 0,
4330
+
},
4331
+
},
4332
+
},
4333
+
output: {
4334
+
encoding: 'application/json',
4335
+
schema: {
4336
+
type: 'object',
4337
+
properties: {
4338
+
shouts: {
4339
+
type: 'array',
4340
+
items: {
4341
+
type: 'ref',
4342
+
ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
4343
+
},
4344
+
},
4345
+
},
4346
+
},
4347
+
},
4348
+
},
4349
+
},
4350
+
},
4351
+
AppRockskyShoutGetArtistShouts: {
4352
+
lexicon: 1,
4353
+
id: 'app.rocksky.shout.getArtistShouts',
4354
+
defs: {
4355
+
main: {
4356
+
type: 'query',
4357
+
description: 'Get shouts for an artist',
4358
+
parameters: {
4359
+
type: 'params',
4360
+
required: ['uri'],
4361
+
properties: {
4362
+
uri: {
4363
+
type: 'string',
4364
+
description: 'The URI of the artist to retrieve shouts for',
4365
+
format: 'at-uri',
4366
+
},
4367
+
limit: {
4368
+
type: 'integer',
4369
+
description: 'The maximum number of shouts to return',
4370
+
minimum: 1,
4371
+
},
4372
+
offset: {
4373
+
type: 'integer',
4374
+
description:
4375
+
'The number of shouts to skip before starting to collect the result set',
4376
+
minimum: 0,
4377
+
},
4378
+
},
4379
+
},
4380
+
output: {
4381
+
encoding: 'application/json',
4382
+
schema: {
4383
+
type: 'object',
4384
+
properties: {
4385
+
shouts: {
4386
+
type: 'array',
4387
+
items: {
4388
+
type: 'ref',
4389
+
ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
4390
+
},
4391
+
},
4392
+
},
4393
+
},
4394
+
},
4395
+
},
4396
+
},
4397
+
},
4398
+
AppRockskyShoutGetProfileShouts: {
4399
+
lexicon: 1,
4400
+
id: 'app.rocksky.shout.getProfileShouts',
4401
+
defs: {
4402
+
main: {
4403
+
type: 'query',
4404
+
description: "Get the shouts of an actor's profile",
4405
+
parameters: {
4406
+
type: 'params',
4407
+
required: ['did'],
4408
+
properties: {
4409
+
did: {
4410
+
type: 'string',
4411
+
description: 'The DID or handle of the actor',
4412
+
format: 'at-identifier',
4413
+
},
4414
+
offset: {
4415
+
type: 'integer',
4416
+
description: 'The offset for pagination',
4417
+
minimum: 0,
4418
+
},
4419
+
limit: {
4420
+
type: 'integer',
4421
+
description: 'The maximum number of shouts to return',
4422
+
minimum: 1,
4423
+
},
4424
+
},
4425
+
},
4426
+
output: {
4427
+
encoding: 'application/json',
4428
+
schema: {
4429
+
type: 'object',
4430
+
properties: {
4431
+
shouts: {
4432
+
type: 'array',
4433
+
items: {
4434
+
type: 'ref',
4435
+
ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
4436
+
},
4437
+
},
4438
+
},
4439
+
},
4440
+
},
4441
+
},
4442
+
},
4443
+
},
4444
+
AppRockskyShoutGetShoutReplies: {
4445
+
lexicon: 1,
4446
+
id: 'app.rocksky.shout.getShoutReplies',
4447
+
defs: {
4448
+
main: {
4449
+
type: 'query',
4450
+
description: 'Get replies to a shout',
4451
+
parameters: {
4452
+
type: 'params',
4453
+
required: ['uri'],
4454
+
properties: {
4455
+
uri: {
4456
+
type: 'string',
4457
+
description: 'The URI of the shout to retrieve replies for',
4458
+
format: 'at-uri',
4459
+
},
4460
+
limit: {
4461
+
type: 'integer',
4462
+
description: 'The maximum number of shouts to return',
4463
+
minimum: 1,
4464
+
},
4465
+
offset: {
4466
+
type: 'integer',
4467
+
description:
4468
+
'The number of shouts to skip before starting to collect the result set',
4469
+
minimum: 0,
4470
+
},
4471
+
},
4472
+
},
4473
+
output: {
4474
+
encoding: 'application/json',
4475
+
schema: {
4476
+
type: 'object',
4477
+
properties: {
4478
+
shouts: {
4479
+
type: 'array',
4480
+
items: {
4481
+
type: 'ref',
4482
+
ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
4483
+
},
4484
+
},
4485
+
},
4486
+
},
4487
+
},
4488
+
},
4489
+
},
4490
+
},
4491
+
AppRockskyShoutGetTrackShouts: {
4492
+
lexicon: 1,
4493
+
id: 'app.rocksky.shout.getTrackShouts',
4494
+
defs: {
4495
+
main: {
4496
+
type: 'query',
4497
+
description: 'Get all shouts for a specific track',
4498
+
parameters: {
4499
+
type: 'params',
4500
+
required: ['uri'],
4501
+
properties: {
4502
+
uri: {
4503
+
type: 'string',
4504
+
description: 'The URI of the track to retrieve shouts for',
4505
+
format: 'at-uri',
4506
+
},
4507
+
},
4508
+
},
4509
+
output: {
4510
+
encoding: 'application/json',
4511
+
schema: {
4512
+
type: 'object',
4513
+
properties: {
4514
+
shouts: {
4515
+
type: 'array',
4516
+
items: {
4517
+
type: 'ref',
4518
+
ref: 'lex:app.rocksky.shout.defs#shoutViewBasic',
4519
+
},
4520
+
},
4521
+
},
4522
+
},
4523
+
},
4524
+
},
4525
+
},
4526
+
},
4527
+
AppRockskyShoutRemoveShout: {
4528
+
lexicon: 1,
4529
+
id: 'app.rocksky.shout.removeShout',
4530
+
defs: {
4531
+
main: {
4532
+
type: 'procedure',
4533
+
description: 'Remove a shout by its ID',
4534
+
parameters: {
4535
+
type: 'params',
4536
+
required: ['id'],
4537
+
properties: {
4538
+
id: {
4539
+
type: 'string',
4540
+
description: 'The ID of the shout to be removed',
4541
+
},
4542
+
},
4543
+
},
4544
+
output: {
4545
+
encoding: 'application/json',
4546
+
schema: {
4547
+
type: 'ref',
4548
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
4549
+
},
4550
+
},
4551
+
},
4552
+
},
4553
+
},
4554
+
AppRockskyShoutReplyShout: {
4555
+
lexicon: 1,
4556
+
id: 'app.rocksky.shout.replyShout',
4557
+
defs: {
4558
+
main: {
4559
+
type: 'procedure',
4560
+
description: 'Reply to a shout',
4561
+
input: {
4562
+
encoding: 'application/json',
4563
+
schema: {
4564
+
type: 'object',
4565
+
required: ['shoutId', 'message'],
4566
+
properties: {
4567
+
shoutId: {
4568
+
type: 'string',
4569
+
description: 'The unique identifier of the shout to reply to',
4570
+
},
4571
+
message: {
4572
+
type: 'string',
4573
+
description: 'The content of the reply',
4574
+
minLength: 1,
4575
+
},
4576
+
},
4577
+
},
4578
+
},
4579
+
output: {
4580
+
encoding: 'application/json',
4581
+
schema: {
4582
+
type: 'ref',
4583
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
4584
+
},
4585
+
},
4586
+
},
4587
+
},
4588
+
},
4589
+
AppRockskyShoutReportShout: {
4590
+
lexicon: 1,
4591
+
id: 'app.rocksky.shout.reportShout',
4592
+
defs: {
4593
+
main: {
4594
+
type: 'procedure',
4595
+
description: 'Report a shout for moderation',
4596
+
input: {
4597
+
encoding: 'application/json',
4598
+
schema: {
4599
+
type: 'object',
4600
+
required: ['shoutId'],
4601
+
properties: {
4602
+
shoutId: {
4603
+
type: 'string',
4604
+
description: 'The unique identifier of the shout to report',
4605
+
},
4606
+
reason: {
4607
+
type: 'string',
4608
+
description: 'The reason for reporting the shout',
4609
+
minLength: 1,
4610
+
},
4611
+
},
4612
+
},
4613
+
},
4614
+
output: {
4615
+
encoding: 'application/json',
4616
+
schema: {
4617
+
type: 'ref',
4618
+
ref: 'lex:app.rocksky.shout.defs#shoutView',
4619
+
},
4620
+
},
4621
+
},
4622
+
},
4623
+
},
4624
+
AppRockskyShout: {
4625
+
lexicon: 1,
4626
+
id: 'app.rocksky.shout',
4627
+
defs: {
4628
+
main: {
4629
+
type: 'record',
4630
+
description: 'A declaration of a shout.',
4631
+
key: 'tid',
4632
+
record: {
4633
+
type: 'object',
4634
+
required: ['message', 'createdAt', 'subject'],
4635
+
properties: {
4636
+
message: {
4637
+
type: 'string',
4638
+
description: 'The message of the shout.',
4639
+
minLength: 1,
4640
+
maxLength: 1000,
4641
+
},
4642
+
createdAt: {
4643
+
type: 'string',
4644
+
description: 'The date when the shout was created.',
4645
+
format: 'datetime',
4646
+
},
4647
+
parent: {
4648
+
type: 'ref',
4649
+
ref: 'lex:com.atproto.repo.strongRef',
4650
+
},
4651
+
subject: {
4652
+
type: 'ref',
4653
+
ref: 'lex:com.atproto.repo.strongRef',
4654
+
},
4655
+
},
4656
+
},
4657
+
},
4658
+
},
4659
+
},
4660
+
AppRockskySongCreateSong: {
4661
+
lexicon: 1,
4662
+
id: 'app.rocksky.song.createSong',
4663
+
defs: {
4664
+
main: {
4665
+
type: 'procedure',
4666
+
description: 'Create a new song',
4667
+
input: {
4668
+
encoding: 'application/json',
4669
+
schema: {
4670
+
type: 'object',
4671
+
required: ['title', 'artist', 'album', 'albumArtist'],
4672
+
properties: {
4673
+
title: {
4674
+
type: 'string',
4675
+
description: 'The title of the song',
4676
+
},
4677
+
artist: {
4678
+
type: 'string',
4679
+
description: 'The artist of the song',
4680
+
},
4681
+
albumArtist: {
4682
+
type: 'string',
4683
+
description:
4684
+
'The album artist of the song, if different from the main artist',
4685
+
},
4686
+
album: {
4687
+
type: 'string',
4688
+
description: 'The album of the song, if applicable',
4689
+
},
4690
+
duration: {
4691
+
type: 'integer',
4692
+
description: 'The duration of the song in seconds',
4693
+
},
4694
+
mbId: {
4695
+
type: 'string',
4696
+
description: 'The MusicBrainz ID of the song, if available',
4697
+
},
4698
+
albumArt: {
4699
+
type: 'string',
4700
+
description: 'The URL of the album art for the song',
4701
+
format: 'uri',
4702
+
},
4703
+
trackNumber: {
4704
+
type: 'integer',
4705
+
description:
4706
+
'The track number of the song in the album, if applicable',
4707
+
},
4708
+
releaseDate: {
4709
+
type: 'string',
4710
+
description:
4711
+
'The release date of the song, formatted as YYYY-MM-DD',
4712
+
},
4713
+
year: {
4714
+
type: 'integer',
4715
+
description: 'The year the song was released',
4716
+
},
4717
+
discNumber: {
4718
+
type: 'integer',
4719
+
description:
4720
+
'The disc number of the song in the album, if applicable',
4721
+
},
4722
+
lyrics: {
4723
+
type: 'string',
4724
+
description: 'The lyrics of the song, if available',
4725
+
},
4726
+
},
4727
+
},
4728
+
},
4729
+
output: {
4730
+
encoding: 'application/json',
4731
+
schema: {
4732
+
type: 'ref',
4733
+
ref: 'lex:app.rocksky.song.defs#songViewDetailed',
4734
+
},
4735
+
},
4736
+
},
4737
+
},
4738
+
},
4739
+
AppRockskySongDefs: {
4740
+
lexicon: 1,
4741
+
id: 'app.rocksky.song.defs',
4742
+
defs: {
4743
+
songViewBasic: {
4744
+
type: 'object',
4745
+
properties: {
4746
+
id: {
4747
+
type: 'string',
4748
+
description: 'The unique identifier of the song.',
4749
+
},
4750
+
title: {
4751
+
type: 'string',
4752
+
description: 'The title of the song.',
4753
+
},
4754
+
artist: {
4755
+
type: 'string',
4756
+
description: 'The artist of the song.',
4757
+
},
4758
+
albumArtist: {
4759
+
type: 'string',
4760
+
description: 'The artist of the album the song belongs to.',
4761
+
},
4762
+
albumArt: {
4763
+
type: 'string',
4764
+
description: 'The URL of the album art image.',
4765
+
format: 'uri',
4766
+
},
4767
+
uri: {
4768
+
type: 'string',
4769
+
description: 'The URI of the song.',
4770
+
format: 'at-uri',
4771
+
},
4772
+
album: {
4773
+
type: 'string',
4774
+
description: 'The album of the song.',
4775
+
},
4776
+
duration: {
4777
+
type: 'integer',
4778
+
description: 'The duration of the song in milliseconds.',
4779
+
},
4780
+
trackNumber: {
4781
+
type: 'integer',
4782
+
description: 'The track number of the song in the album.',
4783
+
},
4784
+
discNumber: {
4785
+
type: 'integer',
4786
+
description: 'The disc number of the song in the album.',
4787
+
},
4788
+
playCount: {
4789
+
type: 'integer',
4790
+
description: 'The number of times the song has been played.',
4791
+
minimum: 0,
4792
+
},
4793
+
uniqueListeners: {
4794
+
type: 'integer',
4795
+
description:
4796
+
'The number of unique listeners who have played the song.',
4797
+
minimum: 0,
4798
+
},
4799
+
albumUri: {
4800
+
type: 'string',
4801
+
description: 'The URI of the album the song belongs to.',
4802
+
format: 'at-uri',
4803
+
},
4804
+
artistUri: {
4805
+
type: 'string',
4806
+
description: 'The URI of the artist of the song.',
4807
+
format: 'at-uri',
4808
+
},
4809
+
sha256: {
4810
+
type: 'string',
4811
+
description: 'The SHA256 hash of the song.',
4812
+
},
4813
+
createdAt: {
4814
+
type: 'string',
4815
+
description: 'The timestamp when the song was created.',
4816
+
format: 'datetime',
4817
+
},
4818
+
},
4819
+
},
4820
+
songViewDetailed: {
4821
+
type: 'object',
4822
+
properties: {
4823
+
id: {
4824
+
type: 'string',
4825
+
description: 'The unique identifier of the song.',
4826
+
},
4827
+
title: {
4828
+
type: 'string',
4829
+
description: 'The title of the song.',
4830
+
},
4831
+
artist: {
4832
+
type: 'string',
4833
+
description: 'The artist of the song.',
4834
+
},
4835
+
albumArtist: {
4836
+
type: 'string',
4837
+
description: 'The artist of the album the song belongs to.',
4838
+
},
4839
+
albumArt: {
4840
+
type: 'string',
4841
+
description: 'The URL of the album art image.',
4842
+
format: 'uri',
4843
+
},
4844
+
uri: {
4845
+
type: 'string',
4846
+
description: 'The URI of the song.',
4847
+
format: 'at-uri',
4848
+
},
4849
+
album: {
4850
+
type: 'string',
4851
+
description: 'The album of the song.',
4852
+
},
4853
+
duration: {
4854
+
type: 'integer',
4855
+
description: 'The duration of the song in milliseconds.',
4856
+
},
4857
+
trackNumber: {
4858
+
type: 'integer',
4859
+
description: 'The track number of the song in the album.',
4860
+
},
4861
+
discNumber: {
4862
+
type: 'integer',
4863
+
description: 'The disc number of the song in the album.',
4864
+
},
4865
+
playCount: {
4866
+
type: 'integer',
4867
+
description: 'The number of times the song has been played.',
4868
+
minimum: 0,
4869
+
},
4870
+
uniqueListeners: {
4871
+
type: 'integer',
4872
+
description:
4873
+
'The number of unique listeners who have played the song.',
4874
+
minimum: 0,
4875
+
},
4876
+
albumUri: {
4877
+
type: 'string',
4878
+
description: 'The URI of the album the song belongs to.',
4879
+
format: 'at-uri',
4880
+
},
4881
+
artistUri: {
4882
+
type: 'string',
4883
+
description: 'The URI of the artist of the song.',
4884
+
format: 'at-uri',
4885
+
},
4886
+
sha256: {
4887
+
type: 'string',
4888
+
description: 'The SHA256 hash of the song.',
4889
+
},
4890
+
createdAt: {
4891
+
type: 'string',
4892
+
description: 'The timestamp when the song was created.',
4893
+
format: 'datetime',
4894
+
},
4895
+
},
4896
+
},
4897
+
},
4898
+
},
4899
+
AppRockskySongGetSong: {
4900
+
lexicon: 1,
4901
+
id: 'app.rocksky.song.getSong',
4902
+
defs: {
4903
+
main: {
4904
+
type: 'query',
4905
+
description: 'Get a song by its uri',
4906
+
parameters: {
4907
+
type: 'params',
4908
+
required: ['uri'],
4909
+
properties: {
4910
+
uri: {
4911
+
type: 'string',
4912
+
description: 'The unique identifier of the song to retrieve',
4913
+
format: 'at-uri',
4914
+
},
4915
+
},
4916
+
},
4917
+
output: {
4918
+
encoding: 'application/json',
4919
+
schema: {
4920
+
type: 'ref',
4921
+
ref: 'lex:app.rocksky.song.defs#songViewDetailed',
4922
+
},
4923
+
},
4924
+
},
4925
+
},
4926
+
},
4927
+
AppRockskySongGetSongs: {
4928
+
lexicon: 1,
4929
+
id: 'app.rocksky.song.getSongs',
4930
+
defs: {
4931
+
main: {
4932
+
type: 'query',
4933
+
description: 'Get songs',
4934
+
parameters: {
4935
+
type: 'params',
4936
+
properties: {
4937
+
limit: {
4938
+
type: 'integer',
4939
+
description: 'The maximum number of songs to return',
4940
+
minimum: 1,
4941
+
},
4942
+
offset: {
4943
+
type: 'integer',
4944
+
description: 'The offset for pagination',
4945
+
minimum: 0,
4946
+
},
4947
+
},
4948
+
},
4949
+
output: {
4950
+
encoding: 'application/json',
4951
+
schema: {
4952
+
type: 'object',
4953
+
properties: {
4954
+
songs: {
4955
+
type: 'array',
4956
+
items: {
4957
+
type: 'ref',
4958
+
ref: 'lex:app.rocksky.song.defs#songViewBasic',
4959
+
},
4960
+
},
4961
+
},
4962
+
},
4963
+
},
4964
+
},
4965
+
},
4966
+
},
4967
+
AppRockskySong: {
4968
+
lexicon: 1,
4969
+
id: 'app.rocksky.song',
4970
+
defs: {
4971
+
main: {
4972
+
type: 'record',
4973
+
description: 'A declaration of a song.',
4974
+
key: 'tid',
4975
+
record: {
4976
+
type: 'object',
4977
+
required: [
4978
+
'title',
4979
+
'artist',
4980
+
'album',
4981
+
'albumArtist',
4982
+
'duration',
4983
+
'createdAt',
4984
+
],
4985
+
properties: {
4986
+
title: {
4987
+
type: 'string',
4988
+
description: 'The title of the song.',
4989
+
minLength: 1,
4990
+
maxLength: 512,
4991
+
},
4992
+
artist: {
4993
+
type: 'string',
4994
+
description: 'The artist of the song.',
4995
+
minLength: 1,
4996
+
maxLength: 256,
4997
+
},
4998
+
artists: {
4999
+
type: 'array',
5000
+
description: 'The artists of the song with MusicBrainz IDs.',
5001
+
items: {
5002
+
type: 'ref',
5003
+
ref: 'lex:app.rocksky.artist.defs#artistMbid',
5004
+
},
5005
+
},
5006
+
albumArtist: {
5007
+
type: 'string',
5008
+
description: 'The album artist of the song.',
5009
+
minLength: 1,
5010
+
maxLength: 256,
5011
+
},
5012
+
album: {
5013
+
type: 'string',
5014
+
description: 'The album of the song.',
5015
+
minLength: 1,
5016
+
maxLength: 256,
5017
+
},
5018
+
duration: {
5019
+
type: 'integer',
5020
+
description: 'The duration of the song in seconds.',
5021
+
minimum: 1,
5022
+
},
5023
+
trackNumber: {
5024
+
type: 'integer',
5025
+
description: 'The track number of the song in the album.',
5026
+
minimum: 1,
5027
+
},
5028
+
discNumber: {
5029
+
type: 'integer',
5030
+
description: 'The disc number of the song in the album.',
5031
+
minimum: 1,
5032
+
},
5033
+
releaseDate: {
5034
+
type: 'string',
5035
+
description: 'The release date of the song.',
5036
+
format: 'datetime',
5037
+
},
5038
+
year: {
5039
+
type: 'integer',
5040
+
description: 'The year the song was released.',
5041
+
},
5042
+
genre: {
5043
+
type: 'string',
5044
+
description: 'The genre of the song.',
5045
+
minLength: 1,
5046
+
maxLength: 256,
5047
+
},
5048
+
tags: {
5049
+
type: 'array',
5050
+
description: 'The tags of the song.',
5051
+
items: {
5052
+
type: 'string',
5053
+
minLength: 1,
5054
+
maxLength: 256,
5055
+
},
5056
+
},
5057
+
composer: {
5058
+
type: 'string',
5059
+
description: 'The composer of the song.',
5060
+
maxLength: 256,
5061
+
},
5062
+
lyrics: {
5063
+
type: 'string',
5064
+
description: 'The lyrics of the song.',
5065
+
maxLength: 10000,
5066
+
},
5067
+
copyrightMessage: {
5068
+
type: 'string',
5069
+
description: 'The copyright message of the song.',
5070
+
maxLength: 256,
5071
+
},
5072
+
wiki: {
5073
+
type: 'string',
5074
+
description: 'Informations about the song',
5075
+
maxLength: 10000,
5076
+
},
5077
+
albumArt: {
5078
+
type: 'blob',
5079
+
description: 'The album art of the song.',
5080
+
accept: ['image/png', 'image/jpeg'],
5081
+
maxSize: 2000000,
5082
+
},
5083
+
albumArtUrl: {
5084
+
type: 'string',
5085
+
description: 'The URL of the album art of the song.',
5086
+
format: 'uri',
5087
+
},
5088
+
youtubeLink: {
5089
+
type: 'string',
5090
+
description: 'The YouTube link of the song.',
5091
+
format: 'uri',
5092
+
},
5093
+
spotifyLink: {
5094
+
type: 'string',
5095
+
description: 'The Spotify link of the song.',
5096
+
format: 'uri',
5097
+
},
5098
+
tidalLink: {
5099
+
type: 'string',
5100
+
description: 'The Tidal link of the song.',
5101
+
format: 'uri',
5102
+
},
5103
+
appleMusicLink: {
5104
+
type: 'string',
5105
+
description: 'The Apple Music link of the song.',
5106
+
format: 'uri',
5107
+
},
5108
+
createdAt: {
5109
+
type: 'string',
5110
+
description: 'The date when the song was created.',
5111
+
format: 'datetime',
5112
+
},
5113
+
mbid: {
5114
+
type: 'string',
5115
+
description: 'The MusicBrainz ID of the song.',
5116
+
},
5117
+
label: {
5118
+
type: 'string',
5119
+
description: 'The label of the song.',
5120
+
maxLength: 256,
5121
+
},
5122
+
},
5123
+
},
5124
+
},
5125
+
},
5126
+
},
5127
+
AppRockskySpotifyDefs: {
5128
+
lexicon: 1,
5129
+
id: 'app.rocksky.spotify.defs',
5130
+
defs: {
5131
+
spotifyTrackView: {
5132
+
type: 'object',
5133
+
properties: {
5134
+
id: {
5135
+
type: 'string',
5136
+
description: 'The unique identifier of the Spotify track.',
5137
+
},
5138
+
name: {
5139
+
type: 'string',
5140
+
description: 'The name of the track.',
5141
+
},
5142
+
artist: {
5143
+
type: 'string',
5144
+
description: 'The name of the artist.',
5145
+
},
5146
+
album: {
5147
+
type: 'string',
5148
+
description: 'The name of the album.',
5149
+
},
5150
+
duration: {
5151
+
type: 'integer',
5152
+
description: 'The duration of the track in milliseconds.',
5153
+
},
5154
+
previewUrl: {
5155
+
type: 'string',
5156
+
description: 'A URL to a preview of the track.',
5157
+
},
5158
+
},
5159
+
},
5160
+
},
5161
+
},
5162
+
AppRockskySpotifyGetCurrentlyPlaying: {
5163
+
lexicon: 1,
5164
+
id: 'app.rocksky.spotify.getCurrentlyPlaying',
5165
+
defs: {
5166
+
main: {
5167
+
type: 'query',
5168
+
description: 'Get the currently playing track',
5169
+
parameters: {
5170
+
type: 'params',
5171
+
properties: {
5172
+
actor: {
5173
+
type: 'string',
5174
+
description:
5175
+
'Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.',
5176
+
format: 'at-identifier',
5177
+
},
5178
+
},
5179
+
},
5180
+
output: {
5181
+
encoding: 'application/json',
5182
+
schema: {
5183
+
type: 'ref',
5184
+
ref: 'lex:app.rocksky.player.defs#currentlyPlayingViewDetailed',
5185
+
},
5186
+
},
5187
+
},
5188
+
},
5189
+
},
5190
+
AppRockskySpotifyNext: {
5191
+
lexicon: 1,
5192
+
id: 'app.rocksky.spotify.next',
5193
+
defs: {
5194
+
main: {
5195
+
type: 'procedure',
5196
+
description: 'Play the next track in the queue',
5197
+
},
5198
+
},
5199
+
},
5200
+
AppRockskySpotifyPause: {
5201
+
lexicon: 1,
5202
+
id: 'app.rocksky.spotify.pause',
5203
+
defs: {
5204
+
main: {
5205
+
type: 'procedure',
5206
+
description: 'Pause the currently playing track',
5207
+
},
5208
+
},
5209
+
},
5210
+
AppRockskySpotifyPlay: {
5211
+
lexicon: 1,
5212
+
id: 'app.rocksky.spotify.play',
5213
+
defs: {
5214
+
main: {
5215
+
type: 'procedure',
5216
+
description: 'Resume playback of the currently paused track',
5217
+
},
5218
+
},
5219
+
},
5220
+
AppRockskySpotifyPrevious: {
5221
+
lexicon: 1,
5222
+
id: 'app.rocksky.spotify.previous',
5223
+
defs: {
5224
+
main: {
5225
+
type: 'procedure',
5226
+
description: 'Play the previous track in the queue',
5227
+
},
5228
+
},
5229
+
},
5230
+
AppRockskySpotifySeek: {
5231
+
lexicon: 1,
5232
+
id: 'app.rocksky.spotify.seek',
5233
+
defs: {
5234
+
main: {
5235
+
type: 'procedure',
5236
+
description:
5237
+
'Seek to a specific position in the currently playing track',
5238
+
parameters: {
5239
+
type: 'params',
5240
+
required: ['position'],
5241
+
properties: {
5242
+
position: {
5243
+
type: 'integer',
5244
+
description: 'The position in seconds to seek to',
5245
+
},
5246
+
},
5247
+
},
5248
+
},
5249
+
},
5250
+
},
5251
+
AppRockskyStatsDefs: {
5252
+
lexicon: 1,
5253
+
id: 'app.rocksky.stats.defs',
5254
+
defs: {
5255
+
statsView: {
5256
+
type: 'object',
5257
+
properties: {
5258
+
scrobbles: {
5259
+
type: 'integer',
5260
+
description: 'The total number of scrobbles.',
5261
+
},
5262
+
artists: {
5263
+
type: 'integer',
5264
+
description: 'The total number of unique artists scrobbled.',
5265
+
},
5266
+
lovedTracks: {
5267
+
type: 'integer',
5268
+
description: 'The total number of tracks marked as loved.',
5269
+
},
5270
+
albums: {
5271
+
type: 'integer',
5272
+
description: 'The total number of unique albums scrobbled.',
5273
+
},
5274
+
tracks: {
5275
+
type: 'integer',
5276
+
description: 'The total number of unique tracks scrobbled.',
5277
+
},
5278
+
},
5279
+
},
5280
+
},
5281
+
},
5282
+
AppRockskyStatsGetStats: {
5283
+
lexicon: 1,
5284
+
id: 'app.rocksky.stats.getStats',
5285
+
defs: {
5286
+
main: {
5287
+
type: 'query',
5288
+
parameters: {
5289
+
type: 'params',
5290
+
required: ['did'],
5291
+
properties: {
5292
+
did: {
5293
+
type: 'string',
5294
+
description: 'The DID or handle of the user to get stats for.',
5295
+
format: 'at-identifier',
5296
+
},
5297
+
},
5298
+
},
5299
+
output: {
5300
+
encoding: 'application/json',
5301
+
schema: {
5302
+
type: 'ref',
5303
+
ref: 'lex:app.rocksky.stats.defs#statsView',
5304
+
},
5305
+
},
5306
+
},
5307
+
},
5308
+
},
5309
+
ComAtprotoRepoStrongRef: {
5310
+
lexicon: 1,
5311
+
id: 'com.atproto.repo.strongRef',
5312
+
description: 'A URI with a content-hash fingerprint.',
5313
+
defs: {
5314
+
main: {
5315
+
type: 'object',
5316
+
required: ['uri', 'cid'],
5317
+
properties: {
5318
+
uri: {
5319
+
type: 'string',
5320
+
format: 'at-uri',
5321
+
},
5322
+
cid: {
5323
+
type: 'string',
5324
+
format: 'cid',
5325
+
},
5326
+
},
5327
+
},
5328
+
},
5329
+
},
5330
+
} as const satisfies Record<string, LexiconDoc>
5331
+
5332
+
export const schemas = Object.values(schemaDict)
5333
+
export const lexicons: Lexicons = new Lexicons(schemas)
5334
+
export const ids = {
5335
+
AppRockskyActorDefs: 'app.rocksky.actor.defs',
5336
+
AppRockskyActorGetActorAlbums: 'app.rocksky.actor.getActorAlbums',
5337
+
AppRockskyActorGetActorArtists: 'app.rocksky.actor.getActorArtists',
5338
+
AppRockskyActorGetActorCompatibility:
5339
+
'app.rocksky.actor.getActorCompatibility',
5340
+
AppRockskyActorGetActorLovedSongs: 'app.rocksky.actor.getActorLovedSongs',
5341
+
AppRockskyActorGetActorNeighbours: 'app.rocksky.actor.getActorNeighbours',
5342
+
AppRockskyActorGetActorPlaylists: 'app.rocksky.actor.getActorPlaylists',
5343
+
AppRockskyActorGetActorScrobbles: 'app.rocksky.actor.getActorScrobbles',
5344
+
AppRockskyActorGetActorSongs: 'app.rocksky.actor.getActorSongs',
5345
+
AppRockskyActorGetProfile: 'app.rocksky.actor.getProfile',
5346
+
AppBskyActorProfile: 'app.bsky.actor.profile',
5347
+
AppRockskyAlbum: 'app.rocksky.album',
5348
+
AppRockskyAlbumDefs: 'app.rocksky.album.defs',
5349
+
AppRockskyAlbumGetAlbum: 'app.rocksky.album.getAlbum',
5350
+
AppRockskyAlbumGetAlbums: 'app.rocksky.album.getAlbums',
5351
+
AppRockskyAlbumGetAlbumTracks: 'app.rocksky.album.getAlbumTracks',
5352
+
AppRockskyApikeyCreateApikey: 'app.rocksky.apikey.createApikey',
5353
+
AppRockskyApikeyDefs: 'app.rocksky.apikey.defs',
5354
+
AppRockskyApikeysDefs: 'app.rocksky.apikeys.defs',
5355
+
AppRockskyApikeyGetApikeys: 'app.rocksky.apikey.getApikeys',
5356
+
AppRockskyApikeyRemoveApikey: 'app.rocksky.apikey.removeApikey',
5357
+
AppRockskyApikeyUpdateApikey: 'app.rocksky.apikey.updateApikey',
5358
+
AppRockskyArtist: 'app.rocksky.artist',
5359
+
AppRockskyArtistDefs: 'app.rocksky.artist.defs',
5360
+
AppRockskyArtistGetArtist: 'app.rocksky.artist.getArtist',
5361
+
AppRockskyArtistGetArtistAlbums: 'app.rocksky.artist.getArtistAlbums',
5362
+
AppRockskyArtistGetArtistListeners: 'app.rocksky.artist.getArtistListeners',
5363
+
AppRockskyArtistGetArtists: 'app.rocksky.artist.getArtists',
5364
+
AppRockskyArtistGetArtistTracks: 'app.rocksky.artist.getArtistTracks',
5365
+
AppRockskyChartsDefs: 'app.rocksky.charts.defs',
5366
+
AppRockskyChartsGetScrobblesChart: 'app.rocksky.charts.getScrobblesChart',
5367
+
AppRockskyDropboxDefs: 'app.rocksky.dropbox.defs',
5368
+
AppRockskyDropboxDownloadFile: 'app.rocksky.dropbox.downloadFile',
5369
+
AppRockskyDropboxGetFiles: 'app.rocksky.dropbox.getFiles',
5370
+
AppRockskyDropboxGetMetadata: 'app.rocksky.dropbox.getMetadata',
5371
+
AppRockskyDropboxGetTemporaryLink: 'app.rocksky.dropbox.getTemporaryLink',
5372
+
AppRockskyFeedDefs: 'app.rocksky.feed.defs',
5373
+
AppRockskyFeedDescribeFeedGenerator: 'app.rocksky.feed.describeFeedGenerator',
5374
+
AppRockskyFeedGenerator: 'app.rocksky.feed.generator',
5375
+
AppRockskyFeedGetFeed: 'app.rocksky.feed.getFeed',
5376
+
AppRockskyFeedGetFeedGenerator: 'app.rocksky.feed.getFeedGenerator',
5377
+
AppRockskyFeedGetFeedGenerators: 'app.rocksky.feed.getFeedGenerators',
5378
+
AppRockskyFeedGetFeedSkeleton: 'app.rocksky.feed.getFeedSkeleton',
5379
+
AppRockskyFeedGetNowPlayings: 'app.rocksky.feed.getNowPlayings',
5380
+
AppRockskyFeedSearch: 'app.rocksky.feed.search',
5381
+
AppRockskyGoogledriveDefs: 'app.rocksky.googledrive.defs',
5382
+
AppRockskyGoogledriveDownloadFile: 'app.rocksky.googledrive.downloadFile',
5383
+
AppRockskyGoogledriveGetFile: 'app.rocksky.googledrive.getFile',
5384
+
AppRockskyGoogledriveGetFiles: 'app.rocksky.googledrive.getFiles',
5385
+
AppRockskyGraphDefs: 'app.rocksky.graph.defs',
5386
+
AppRockskyGraphFollow: 'app.rocksky.graph.follow',
5387
+
AppRockskyGraphFollowAccount: 'app.rocksky.graph.followAccount',
5388
+
AppRockskyGraphGetFollowers: 'app.rocksky.graph.getFollowers',
5389
+
AppRockskyGraphGetFollows: 'app.rocksky.graph.getFollows',
5390
+
AppRockskyGraphGetKnownFollowers: 'app.rocksky.graph.getKnownFollowers',
5391
+
AppRockskyGraphUnfollowAccount: 'app.rocksky.graph.unfollowAccount',
5392
+
AppRockskyLikeDislikeShout: 'app.rocksky.like.dislikeShout',
5393
+
AppRockskyLikeDislikeSong: 'app.rocksky.like.dislikeSong',
5394
+
AppRockskyLike: 'app.rocksky.like',
5395
+
AppRockskyLikeLikeShout: 'app.rocksky.like.likeShout',
5396
+
AppRockskyLikeLikeSong: 'app.rocksky.like.likeSong',
5397
+
AppRockskyPlayerAddDirectoryToQueue: 'app.rocksky.player.addDirectoryToQueue',
5398
+
AppRockskyPlayerAddItemsToQueue: 'app.rocksky.player.addItemsToQueue',
5399
+
AppRockskyPlayerDefs: 'app.rocksky.player.defs',
5400
+
AppRockskyPlayerGetCurrentlyPlaying: 'app.rocksky.player.getCurrentlyPlaying',
5401
+
AppRockskyPlayerGetPlaybackQueue: 'app.rocksky.player.getPlaybackQueue',
5402
+
AppRockskyPlayerNext: 'app.rocksky.player.next',
5403
+
AppRockskyPlayerPause: 'app.rocksky.player.pause',
5404
+
AppRockskyPlayerPlay: 'app.rocksky.player.play',
5405
+
AppRockskyPlayerPlayDirectory: 'app.rocksky.player.playDirectory',
5406
+
AppRockskyPlayerPlayFile: 'app.rocksky.player.playFile',
5407
+
AppRockskyPlayerPrevious: 'app.rocksky.player.previous',
5408
+
AppRockskyPlayerSeek: 'app.rocksky.player.seek',
5409
+
AppRockskyPlaylistCreatePlaylist: 'app.rocksky.playlist.createPlaylist',
5410
+
AppRockskyPlaylistDefs: 'app.rocksky.playlist.defs',
5411
+
AppRockskyPlaylistGetPlaylist: 'app.rocksky.playlist.getPlaylist',
5412
+
AppRockskyPlaylistGetPlaylists: 'app.rocksky.playlist.getPlaylists',
5413
+
AppRockskyPlaylistInsertDirectory: 'app.rocksky.playlist.insertDirectory',
5414
+
AppRockskyPlaylistInsertFiles: 'app.rocksky.playlist.insertFiles',
5415
+
AppRockskyPlaylist: 'app.rocksky.playlist',
5416
+
AppRockskyPlaylistRemovePlaylist: 'app.rocksky.playlist.removePlaylist',
5417
+
AppRockskyPlaylistRemoveTrack: 'app.rocksky.playlist.removeTrack',
5418
+
AppRockskyPlaylistStartPlaylist: 'app.rocksky.playlist.startPlaylist',
5419
+
AppRockskyRadioDefs: 'app.rocksky.radio.defs',
5420
+
AppRockskyRadio: 'app.rocksky.radio',
5421
+
AppRockskyScrobbleCreateScrobble: 'app.rocksky.scrobble.createScrobble',
5422
+
AppRockskyScrobbleDefs: 'app.rocksky.scrobble.defs',
5423
+
AppRockskyScrobbleGetScrobble: 'app.rocksky.scrobble.getScrobble',
5424
+
AppRockskyScrobbleGetScrobbles: 'app.rocksky.scrobble.getScrobbles',
5425
+
AppRockskyScrobble: 'app.rocksky.scrobble',
5426
+
AppRockskyShoutCreateShout: 'app.rocksky.shout.createShout',
5427
+
AppRockskyShoutDefs: 'app.rocksky.shout.defs',
5428
+
AppRockskyShoutGetAlbumShouts: 'app.rocksky.shout.getAlbumShouts',
5429
+
AppRockskyShoutGetArtistShouts: 'app.rocksky.shout.getArtistShouts',
5430
+
AppRockskyShoutGetProfileShouts: 'app.rocksky.shout.getProfileShouts',
5431
+
AppRockskyShoutGetShoutReplies: 'app.rocksky.shout.getShoutReplies',
5432
+
AppRockskyShoutGetTrackShouts: 'app.rocksky.shout.getTrackShouts',
5433
+
AppRockskyShoutRemoveShout: 'app.rocksky.shout.removeShout',
5434
+
AppRockskyShoutReplyShout: 'app.rocksky.shout.replyShout',
5435
+
AppRockskyShoutReportShout: 'app.rocksky.shout.reportShout',
5436
+
AppRockskyShout: 'app.rocksky.shout',
5437
+
AppRockskySongCreateSong: 'app.rocksky.song.createSong',
5438
+
AppRockskySongDefs: 'app.rocksky.song.defs',
5439
+
AppRockskySongGetSong: 'app.rocksky.song.getSong',
5440
+
AppRockskySongGetSongs: 'app.rocksky.song.getSongs',
5441
+
AppRockskySong: 'app.rocksky.song',
5442
+
AppRockskySpotifyDefs: 'app.rocksky.spotify.defs',
5443
+
AppRockskySpotifyGetCurrentlyPlaying:
5444
+
'app.rocksky.spotify.getCurrentlyPlaying',
5445
+
AppRockskySpotifyNext: 'app.rocksky.spotify.next',
5446
+
AppRockskySpotifyPause: 'app.rocksky.spotify.pause',
5447
+
AppRockskySpotifyPlay: 'app.rocksky.spotify.play',
5448
+
AppRockskySpotifyPrevious: 'app.rocksky.spotify.previous',
5449
+
AppRockskySpotifySeek: 'app.rocksky.spotify.seek',
5450
+
AppRockskyStatsDefs: 'app.rocksky.stats.defs',
5451
+
AppRockskyStatsGetStats: 'app.rocksky.stats.getStats',
5452
+
ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
5453
+
}
+38
apps/cli/src/lexicon/types/app/bsky/actor/profile.ts
+38
apps/cli/src/lexicon/types/app/bsky/actor/profile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
9
+
import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
10
+
11
+
export interface Record {
12
+
displayName?: string
13
+
/** Free-form profile description text. */
14
+
description?: string
15
+
/** Small image to be displayed next to posts from account. AKA, 'profile picture' */
16
+
avatar?: BlobRef
17
+
/** Larger horizontal image to display behind profile view. */
18
+
banner?: BlobRef
19
+
labels?:
20
+
| ComAtprotoLabelDefs.SelfLabels
21
+
| { $type: string; [k: string]: unknown }
22
+
joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
23
+
createdAt?: string
24
+
[k: string]: unknown
25
+
}
26
+
27
+
export function isRecord(v: unknown): v is Record {
28
+
return (
29
+
isObj(v) &&
30
+
hasProp(v, '$type') &&
31
+
(v.$type === 'app.bsky.actor.profile#main' ||
32
+
v.$type === 'app.bsky.actor.profile')
33
+
)
34
+
}
35
+
36
+
export function validateRecord(v: unknown): ValidationResult {
37
+
return lexicons.validate('app.bsky.actor.profile#main', v)
38
+
}
+146
apps/cli/src/lexicon/types/app/rocksky/actor/defs.ts
+146
apps/cli/src/lexicon/types/app/rocksky/actor/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskyArtistDefs from '../artist/defs'
9
+
10
+
export interface ProfileViewDetailed {
11
+
/** The unique identifier of the actor. */
12
+
id?: string
13
+
/** The DID of the actor. */
14
+
did?: string
15
+
/** The handle of the actor. */
16
+
handle?: string
17
+
/** The display name of the actor. */
18
+
displayName?: string
19
+
/** The URL of the actor's avatar image. */
20
+
avatar?: string
21
+
/** The date and time when the actor was created. */
22
+
createdAt?: string
23
+
/** The date and time when the actor was last updated. */
24
+
updatedAt?: string
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export function isProfileViewDetailed(v: unknown): v is ProfileViewDetailed {
29
+
return (
30
+
isObj(v) &&
31
+
hasProp(v, '$type') &&
32
+
v.$type === 'app.rocksky.actor.defs#profileViewDetailed'
33
+
)
34
+
}
35
+
36
+
export function validateProfileViewDetailed(v: unknown): ValidationResult {
37
+
return lexicons.validate('app.rocksky.actor.defs#profileViewDetailed', v)
38
+
}
39
+
40
+
export interface ProfileViewBasic {
41
+
/** The unique identifier of the actor. */
42
+
id?: string
43
+
/** The DID of the actor. */
44
+
did?: string
45
+
/** The handle of the actor. */
46
+
handle?: string
47
+
/** The display name of the actor. */
48
+
displayName?: string
49
+
/** The URL of the actor's avatar image. */
50
+
avatar?: string
51
+
/** The date and time when the actor was created. */
52
+
createdAt?: string
53
+
/** The date and time when the actor was last updated. */
54
+
updatedAt?: string
55
+
[k: string]: unknown
56
+
}
57
+
58
+
export function isProfileViewBasic(v: unknown): v is ProfileViewBasic {
59
+
return (
60
+
isObj(v) &&
61
+
hasProp(v, '$type') &&
62
+
v.$type === 'app.rocksky.actor.defs#profileViewBasic'
63
+
)
64
+
}
65
+
66
+
export function validateProfileViewBasic(v: unknown): ValidationResult {
67
+
return lexicons.validate('app.rocksky.actor.defs#profileViewBasic', v)
68
+
}
69
+
70
+
export interface NeighbourViewBasic {
71
+
userId?: string
72
+
did?: string
73
+
handle?: string
74
+
displayName?: string
75
+
/** The URL of the actor's avatar image. */
76
+
avatar?: string
77
+
/** The number of artists shared with the actor. */
78
+
sharedArtistsCount?: number
79
+
/** The similarity score with the actor. */
80
+
similarityScore?: number
81
+
/** The top shared artist names with the actor. */
82
+
topSharedArtistNames?: string[]
83
+
/** The top shared artist details with the actor. */
84
+
topSharedArtistsDetails?: AppRockskyArtistDefs.ArtistViewBasic[]
85
+
[k: string]: unknown
86
+
}
87
+
88
+
export function isNeighbourViewBasic(v: unknown): v is NeighbourViewBasic {
89
+
return (
90
+
isObj(v) &&
91
+
hasProp(v, '$type') &&
92
+
v.$type === 'app.rocksky.actor.defs#neighbourViewBasic'
93
+
)
94
+
}
95
+
96
+
export function validateNeighbourViewBasic(v: unknown): ValidationResult {
97
+
return lexicons.validate('app.rocksky.actor.defs#neighbourViewBasic', v)
98
+
}
99
+
100
+
export interface CompatibilityViewBasic {
101
+
compatibilityLevel?: number
102
+
compatibilityPercentage?: number
103
+
sharedArtists?: number
104
+
topSharedArtistNames?: string[]
105
+
topSharedDetailedArtists?: ArtistViewBasic[]
106
+
user1ArtistCount?: number
107
+
user2ArtistCount?: number
108
+
[k: string]: unknown
109
+
}
110
+
111
+
export function isCompatibilityViewBasic(
112
+
v: unknown,
113
+
): v is CompatibilityViewBasic {
114
+
return (
115
+
isObj(v) &&
116
+
hasProp(v, '$type') &&
117
+
v.$type === 'app.rocksky.actor.defs#compatibilityViewBasic'
118
+
)
119
+
}
120
+
121
+
export function validateCompatibilityViewBasic(v: unknown): ValidationResult {
122
+
return lexicons.validate('app.rocksky.actor.defs#compatibilityViewBasic', v)
123
+
}
124
+
125
+
export interface ArtistViewBasic {
126
+
id?: string
127
+
name?: string
128
+
picture?: string
129
+
uri?: string
130
+
user1Rank?: number
131
+
user2Rank?: number
132
+
weight?: number
133
+
[k: string]: unknown
134
+
}
135
+
136
+
export function isArtistViewBasic(v: unknown): v is ArtistViewBasic {
137
+
return (
138
+
isObj(v) &&
139
+
hasProp(v, '$type') &&
140
+
v.$type === 'app.rocksky.actor.defs#artistViewBasic'
141
+
)
142
+
}
143
+
144
+
export function validateArtistViewBasic(v: unknown): ValidationResult {
145
+
return lexicons.validate('app.rocksky.actor.defs#artistViewBasic', v)
146
+
}
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorAlbums.ts
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorAlbums.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyAlbumDefs from '../album/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
/** The start date to filter albums from (ISO 8601 format) */
20
+
startDate?: string
21
+
/** The end date to filter albums to (ISO 8601 format) */
22
+
endDate?: string
23
+
}
24
+
25
+
export type InputSchema = undefined
26
+
27
+
export interface OutputSchema {
28
+
albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorArtists.ts
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorArtists.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyArtistDefs from '../artist/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
/** The start date to filter albums from (ISO 8601 format) */
20
+
startDate?: string
21
+
/** The end date to filter albums to (ISO 8601 format) */
22
+
endDate?: string
23
+
}
24
+
25
+
export type InputSchema = undefined
26
+
27
+
export interface OutputSchema {
28
+
artists?: AppRockskyArtistDefs.ArtistViewBasic[]
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/actor/getActorCompatibility.ts
+48
apps/cli/src/lexicon/types/app/rocksky/actor/getActorCompatibility.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** DID or handle to get compatibility for */
14
+
did: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
compatibility?: AppRockskyActorDefs.CompatibilityViewBasic
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorLovedSongs.ts
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorLovedSongs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
tracks?: AppRockskySongDefs.SongViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/actor/getActorNeighbours.ts
+48
apps/cli/src/lexicon/types/app/rocksky/actor/getActorNeighbours.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
neighbours?: AppRockskyActorDefs.NeighbourViewBasic[]
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorPlaylists.ts
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorPlaylists.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlaylistDefs from '../playlist/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorScrobbles.ts
+52
apps/cli/src/lexicon/types/app/rocksky/actor/getActorScrobbles.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyScrobbleDefs from '../scrobble/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorSongs.ts
+56
apps/cli/src/lexicon/types/app/rocksky/actor/getActorSongs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The maximum number of albums to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
/** The start date to filter albums from (ISO 8601 format) */
20
+
startDate?: string
21
+
/** The end date to filter albums to (ISO 8601 format) */
22
+
endDate?: string
23
+
}
24
+
25
+
export type InputSchema = undefined
26
+
27
+
export interface OutputSchema {
28
+
songs?: AppRockskySongDefs.SongViewBasic[]
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/actor/getProfile.ts
+43
apps/cli/src/lexicon/types/app/rocksky/actor/getProfile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did?: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyActorDefs.ProfileViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+51
apps/cli/src/lexicon/types/app/rocksky/album.ts
+51
apps/cli/src/lexicon/types/app/rocksky/album.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Record {
10
+
/** The title of the album. */
11
+
title: string
12
+
/** The artist of the album. */
13
+
artist: string
14
+
/** The duration of the album in seconds. */
15
+
duration?: number
16
+
/** The release date of the album. */
17
+
releaseDate?: string
18
+
/** The year the album was released. */
19
+
year?: number
20
+
/** The genre of the album. */
21
+
genre?: string
22
+
/** The album art of the album. */
23
+
albumArt?: BlobRef
24
+
/** The URL of the album art of the album. */
25
+
albumArtUrl?: string
26
+
/** The tags of the album. */
27
+
tags?: string[]
28
+
/** The YouTube link of the album. */
29
+
youtubeLink?: string
30
+
/** The Spotify link of the album. */
31
+
spotifyLink?: string
32
+
/** The tidal link of the album. */
33
+
tidalLink?: string
34
+
/** The Apple Music link of the album. */
35
+
appleMusicLink?: string
36
+
/** The date and time when the album was created. */
37
+
createdAt: string
38
+
[k: string]: unknown
39
+
}
40
+
41
+
export function isRecord(v: unknown): v is Record {
42
+
return (
43
+
isObj(v) &&
44
+
hasProp(v, '$type') &&
45
+
(v.$type === 'app.rocksky.album#main' || v.$type === 'app.rocksky.album')
46
+
)
47
+
}
48
+
49
+
export function validateRecord(v: unknown): ValidationResult {
50
+
return lexicons.validate('app.rocksky.album#main', v)
51
+
}
+85
apps/cli/src/lexicon/types/app/rocksky/album/defs.ts
+85
apps/cli/src/lexicon/types/app/rocksky/album/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskySongDefsSongViewBasic from '../song/defs/songViewBasic'
9
+
10
+
export interface AlbumViewBasic {
11
+
/** The unique identifier of the album. */
12
+
id?: string
13
+
/** The URI of the album. */
14
+
uri?: string
15
+
/** The title of the album. */
16
+
title?: string
17
+
/** The artist of the album. */
18
+
artist?: string
19
+
/** The URI of the album's artist. */
20
+
artistUri?: string
21
+
/** The year the album was released. */
22
+
year?: number
23
+
/** The URL of the album art image. */
24
+
albumArt?: string
25
+
/** The release date of the album. */
26
+
releaseDate?: string
27
+
/** The SHA256 hash of the album. */
28
+
sha256?: string
29
+
/** The number of times the album has been played. */
30
+
playCount?: number
31
+
/** The number of unique listeners who have played the album. */
32
+
uniqueListeners?: number
33
+
[k: string]: unknown
34
+
}
35
+
36
+
export function isAlbumViewBasic(v: unknown): v is AlbumViewBasic {
37
+
return (
38
+
isObj(v) &&
39
+
hasProp(v, '$type') &&
40
+
v.$type === 'app.rocksky.album.defs#albumViewBasic'
41
+
)
42
+
}
43
+
44
+
export function validateAlbumViewBasic(v: unknown): ValidationResult {
45
+
return lexicons.validate('app.rocksky.album.defs#albumViewBasic', v)
46
+
}
47
+
48
+
export interface AlbumViewDetailed {
49
+
/** The unique identifier of the album. */
50
+
id?: string
51
+
/** The URI of the album. */
52
+
uri?: string
53
+
/** The title of the album. */
54
+
title?: string
55
+
/** The artist of the album. */
56
+
artist?: string
57
+
/** The URI of the album's artist. */
58
+
artistUri?: string
59
+
/** The year the album was released. */
60
+
year?: number
61
+
/** The URL of the album art image. */
62
+
albumArt?: string
63
+
/** The release date of the album. */
64
+
releaseDate?: string
65
+
/** The SHA256 hash of the album. */
66
+
sha256?: string
67
+
/** The number of times the album has been played. */
68
+
playCount?: number
69
+
/** The number of unique listeners who have played the album. */
70
+
uniqueListeners?: number
71
+
tracks?: AppRockskySongDefsSongViewBasic.Main[]
72
+
[k: string]: unknown
73
+
}
74
+
75
+
export function isAlbumViewDetailed(v: unknown): v is AlbumViewDetailed {
76
+
return (
77
+
isObj(v) &&
78
+
hasProp(v, '$type') &&
79
+
v.$type === 'app.rocksky.album.defs#albumViewDetailed'
80
+
)
81
+
}
82
+
83
+
export function validateAlbumViewDetailed(v: unknown): ValidationResult {
84
+
return lexicons.validate('app.rocksky.album.defs#albumViewDetailed', v)
85
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/album/getAlbum.ts
+43
apps/cli/src/lexicon/types/app/rocksky/album/getAlbum.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyAlbumDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the album to retrieve. */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyAlbumDefs.AlbumViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/album/getAlbumTracks.ts
+48
apps/cli/src/lexicon/types/app/rocksky/album/getAlbumTracks.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the album to retrieve tracks from */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
tracks?: AppRockskySongDefs.SongViewBasic[]
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+50
apps/cli/src/lexicon/types/app/rocksky/album/getAlbums.ts
+50
apps/cli/src/lexicon/types/app/rocksky/album/getAlbums.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyAlbumDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of albums to return */
14
+
limit?: number
15
+
/** The offset for pagination */
16
+
offset?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
21
+
export interface OutputSchema {
22
+
albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+51
apps/cli/src/lexicon/types/app/rocksky/apikey/createApikey.ts
+51
apps/cli/src/lexicon/types/app/rocksky/apikey/createApikey.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyApikeyDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The name of the API key. */
16
+
name: string
17
+
/** A description for the API key. */
18
+
description?: string
19
+
[k: string]: unknown
20
+
}
21
+
22
+
export type OutputSchema = AppRockskyApikeyDefs.ApiKey
23
+
24
+
export interface HandlerInput {
25
+
encoding: 'application/json'
26
+
body: InputSchema
27
+
}
28
+
29
+
export interface HandlerSuccess {
30
+
encoding: 'application/json'
31
+
body: OutputSchema
32
+
headers?: { [key: string]: string }
33
+
}
34
+
35
+
export interface HandlerError {
36
+
status: number
37
+
message?: string
38
+
}
39
+
40
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
41
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
42
+
auth: HA
43
+
params: QueryParams
44
+
input: HandlerInput
45
+
req: express.Request
46
+
res: express.Response
47
+
resetRouteRateLimits: () => Promise<void>
48
+
}
49
+
export type Handler<HA extends HandlerAuth = never> = (
50
+
ctx: HandlerReqCtx<HA>,
51
+
) => Promise<HandlerOutput> | HandlerOutput
+31
apps/cli/src/lexicon/types/app/rocksky/apikey/defs.ts
+31
apps/cli/src/lexicon/types/app/rocksky/apikey/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface ApiKeyView {
10
+
/** The unique identifier of the API key. */
11
+
id?: string
12
+
/** The name of the API key. */
13
+
name?: string
14
+
/** A description for the API key. */
15
+
description?: string
16
+
/** The date and time when the API key was created. */
17
+
createdAt?: string
18
+
[k: string]: unknown
19
+
}
20
+
21
+
export function isApiKeyView(v: unknown): v is ApiKeyView {
22
+
return (
23
+
isObj(v) &&
24
+
hasProp(v, '$type') &&
25
+
v.$type === 'app.rocksky.apikey.defs#apiKeyView'
26
+
)
27
+
}
28
+
29
+
export function validateApiKeyView(v: unknown): ValidationResult {
30
+
return lexicons.validate('app.rocksky.apikey.defs#apiKeyView', v)
31
+
}
+50
apps/cli/src/lexicon/types/app/rocksky/apikey/getApikeys.ts
+50
apps/cli/src/lexicon/types/app/rocksky/apikey/getApikeys.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyApikeyDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The number of API keys to skip before starting to collect the result set. */
14
+
offset?: number
15
+
/** The number of API keys to return per page. */
16
+
limit?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
21
+
export interface OutputSchema {
22
+
apiKeys?: AppRockskyApikeyDefs.ApikeyView[]
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/apikey/removeApikey.ts
+43
apps/cli/src/lexicon/types/app/rocksky/apikey/removeApikey.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyApikeyDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the API key to remove. */
14
+
id: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyApikeyDefs.ApiKey
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+53
apps/cli/src/lexicon/types/app/rocksky/apikey/updateApikey.ts
+53
apps/cli/src/lexicon/types/app/rocksky/apikey/updateApikey.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyApikeyDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The ID of the API key to update. */
16
+
id: string
17
+
/** The new name of the API key. */
18
+
name: string
19
+
/** A new description for the API key. */
20
+
description?: string
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type OutputSchema = AppRockskyApikeyDefs.ApiKey
25
+
26
+
export interface HandlerInput {
27
+
encoding: 'application/json'
28
+
body: InputSchema
29
+
}
30
+
31
+
export interface HandlerSuccess {
32
+
encoding: 'application/json'
33
+
body: OutputSchema
34
+
headers?: { [key: string]: string }
35
+
}
36
+
37
+
export interface HandlerError {
38
+
status: number
39
+
message?: string
40
+
}
41
+
42
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
43
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
44
+
auth: HA
45
+
params: QueryParams
46
+
input: HandlerInput
47
+
req: express.Request
48
+
res: express.Response
49
+
resetRouteRateLimits: () => Promise<void>
50
+
}
51
+
export type Handler<HA extends HandlerAuth = never> = (
52
+
ctx: HandlerReqCtx<HA>,
53
+
) => Promise<HandlerOutput> | HandlerOutput
+7
apps/cli/src/lexicon/types/app/rocksky/apikeys/defs.ts
+7
apps/cli/src/lexicon/types/app/rocksky/apikeys/defs.ts
+41
apps/cli/src/lexicon/types/app/rocksky/artist.ts
+41
apps/cli/src/lexicon/types/app/rocksky/artist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Record {
10
+
/** The name of the artist. */
11
+
name: string
12
+
/** The biography of the artist. */
13
+
bio?: string
14
+
/** The picture of the artist. */
15
+
picture?: BlobRef
16
+
/** The URL of the picture of the artist. */
17
+
pictureUrl?: string
18
+
/** The tags of the artist. */
19
+
tags?: string[]
20
+
/** The birth date of the artist. */
21
+
born?: string
22
+
/** The death date of the artist. */
23
+
died?: string
24
+
/** The birth place of the artist. */
25
+
bornIn?: string
26
+
/** The date when the artist was created. */
27
+
createdAt: string
28
+
[k: string]: unknown
29
+
}
30
+
31
+
export function isRecord(v: unknown): v is Record {
32
+
return (
33
+
isObj(v) &&
34
+
hasProp(v, '$type') &&
35
+
(v.$type === 'app.rocksky.artist#main' || v.$type === 'app.rocksky.artist')
36
+
)
37
+
}
38
+
39
+
export function validateRecord(v: unknown): ValidationResult {
40
+
return lexicons.validate('app.rocksky.artist#main', v)
41
+
}
+140
apps/cli/src/lexicon/types/app/rocksky/artist/defs.ts
+140
apps/cli/src/lexicon/types/app/rocksky/artist/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface ArtistViewBasic {
10
+
/** The unique identifier of the artist. */
11
+
id?: string
12
+
/** The URI of the artist. */
13
+
uri?: string
14
+
/** The name of the artist. */
15
+
name?: string
16
+
/** The picture of the artist. */
17
+
picture?: string
18
+
/** The SHA256 hash of the artist. */
19
+
sha256?: string
20
+
/** The number of times the artist has been played. */
21
+
playCount?: number
22
+
/** The number of unique listeners who have played the artist. */
23
+
uniqueListeners?: number
24
+
[k: string]: unknown
25
+
}
26
+
27
+
export function isArtistViewBasic(v: unknown): v is ArtistViewBasic {
28
+
return (
29
+
isObj(v) &&
30
+
hasProp(v, '$type') &&
31
+
v.$type === 'app.rocksky.artist.defs#artistViewBasic'
32
+
)
33
+
}
34
+
35
+
export function validateArtistViewBasic(v: unknown): ValidationResult {
36
+
return lexicons.validate('app.rocksky.artist.defs#artistViewBasic', v)
37
+
}
38
+
39
+
export interface ArtistViewDetailed {
40
+
/** The unique identifier of the artist. */
41
+
id?: string
42
+
/** The URI of the artist. */
43
+
uri?: string
44
+
/** The name of the artist. */
45
+
name?: string
46
+
/** The picture of the artist. */
47
+
picture?: string
48
+
/** The SHA256 hash of the artist. */
49
+
sha256?: string
50
+
/** The number of times the artist has been played. */
51
+
playCount?: number
52
+
/** The number of unique listeners who have played the artist. */
53
+
uniqueListeners?: number
54
+
[k: string]: unknown
55
+
}
56
+
57
+
export function isArtistViewDetailed(v: unknown): v is ArtistViewDetailed {
58
+
return (
59
+
isObj(v) &&
60
+
hasProp(v, '$type') &&
61
+
v.$type === 'app.rocksky.artist.defs#artistViewDetailed'
62
+
)
63
+
}
64
+
65
+
export function validateArtistViewDetailed(v: unknown): ValidationResult {
66
+
return lexicons.validate('app.rocksky.artist.defs#artistViewDetailed', v)
67
+
}
68
+
69
+
export interface SongViewBasic {
70
+
/** The URI of the song. */
71
+
uri?: string
72
+
/** The title of the song. */
73
+
title?: string
74
+
/** The number of times the song has been played. */
75
+
playCount?: number
76
+
[k: string]: unknown
77
+
}
78
+
79
+
export function isSongViewBasic(v: unknown): v is SongViewBasic {
80
+
return (
81
+
isObj(v) &&
82
+
hasProp(v, '$type') &&
83
+
v.$type === 'app.rocksky.artist.defs#songViewBasic'
84
+
)
85
+
}
86
+
87
+
export function validateSongViewBasic(v: unknown): ValidationResult {
88
+
return lexicons.validate('app.rocksky.artist.defs#songViewBasic', v)
89
+
}
90
+
91
+
export interface ListenerViewBasic {
92
+
/** The unique identifier of the actor. */
93
+
id?: string
94
+
/** The DID of the listener. */
95
+
did?: string
96
+
/** The handle of the listener. */
97
+
handle?: string
98
+
/** The display name of the listener. */
99
+
displayName?: string
100
+
/** The URL of the listener's avatar image. */
101
+
avatar?: string
102
+
mostListenedSong?: SongViewBasic
103
+
/** The total number of plays by the listener. */
104
+
totalPlays?: number
105
+
/** The rank of the listener among all listeners of the artist. */
106
+
rank?: number
107
+
[k: string]: unknown
108
+
}
109
+
110
+
export function isListenerViewBasic(v: unknown): v is ListenerViewBasic {
111
+
return (
112
+
isObj(v) &&
113
+
hasProp(v, '$type') &&
114
+
v.$type === 'app.rocksky.artist.defs#listenerViewBasic'
115
+
)
116
+
}
117
+
118
+
export function validateListenerViewBasic(v: unknown): ValidationResult {
119
+
return lexicons.validate('app.rocksky.artist.defs#listenerViewBasic', v)
120
+
}
121
+
122
+
export interface ArtistMbid {
123
+
/** The MusicBrainz Identifier (MBID) of the artist. */
124
+
mbid?: string
125
+
/** The name of the artist. */
126
+
name?: string
127
+
[k: string]: unknown
128
+
}
129
+
130
+
export function isArtistMbid(v: unknown): v is ArtistMbid {
131
+
return (
132
+
isObj(v) &&
133
+
hasProp(v, '$type') &&
134
+
v.$type === 'app.rocksky.artist.defs#artistMbid'
135
+
)
136
+
}
137
+
138
+
export function validateArtistMbid(v: unknown): ValidationResult {
139
+
return lexicons.validate('app.rocksky.artist.defs#artistMbid', v)
140
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/artist/getArtist.ts
+43
apps/cli/src/lexicon/types/app/rocksky/artist/getArtist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyArtistDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the artist to retrieve details from */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyArtistDefs.ArtistViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistAlbums.ts
+48
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistAlbums.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyAlbumDefs from '../album/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the artist to retrieve albums from */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
albums?: AppRockskyAlbumDefs.AlbumViewBasic[]
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistListeners.ts
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistListeners.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyArtistDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the artist to retrieve listeners from */
14
+
uri: string
15
+
/** Number of items to skip before returning results */
16
+
offset?: number
17
+
/** Maximum number of results to return */
18
+
limit?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
listeners?: AppRockskyArtistDefs.ListenerViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistTracks.ts
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtistTracks.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the artist to retrieve albums from */
14
+
uri?: string
15
+
/** The maximum number of tracks to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
tracks?: AppRockskySongDefs.SongViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtists.ts
+52
apps/cli/src/lexicon/types/app/rocksky/artist/getArtists.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyArtistDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of artists to return */
14
+
limit?: number
15
+
/** The offset for pagination */
16
+
offset?: number
17
+
/** The names of the artists to return */
18
+
names?: string
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
artists?: AppRockskyArtistDefs.ArtistViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+44
apps/cli/src/lexicon/types/app/rocksky/charts/defs.ts
+44
apps/cli/src/lexicon/types/app/rocksky/charts/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface ChartsView {
10
+
scrobbles?: ScrobbleViewBasic[]
11
+
[k: string]: unknown
12
+
}
13
+
14
+
export function isChartsView(v: unknown): v is ChartsView {
15
+
return (
16
+
isObj(v) &&
17
+
hasProp(v, '$type') &&
18
+
v.$type === 'app.rocksky.charts.defs#chartsView'
19
+
)
20
+
}
21
+
22
+
export function validateChartsView(v: unknown): ValidationResult {
23
+
return lexicons.validate('app.rocksky.charts.defs#chartsView', v)
24
+
}
25
+
26
+
export interface ScrobbleViewBasic {
27
+
/** The date of the scrobble. */
28
+
date?: string
29
+
/** The number of scrobbles on this date. */
30
+
count?: number
31
+
[k: string]: unknown
32
+
}
33
+
34
+
export function isScrobbleViewBasic(v: unknown): v is ScrobbleViewBasic {
35
+
return (
36
+
isObj(v) &&
37
+
hasProp(v, '$type') &&
38
+
v.$type === 'app.rocksky.charts.defs#scrobbleViewBasic'
39
+
)
40
+
}
41
+
42
+
export function validateScrobbleViewBasic(v: unknown): ValidationResult {
43
+
return lexicons.validate('app.rocksky.charts.defs#scrobbleViewBasic', v)
44
+
}
+49
apps/cli/src/lexicon/types/app/rocksky/charts/getScrobblesChart.ts
+49
apps/cli/src/lexicon/types/app/rocksky/charts/getScrobblesChart.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyChartsDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did?: string
15
+
/** The URI of the artist to filter by */
16
+
artisturi?: string
17
+
/** The URI of the album to filter by */
18
+
albumuri?: string
19
+
/** The URI of the track to filter by */
20
+
songuri?: string
21
+
}
22
+
23
+
export type InputSchema = undefined
24
+
export type OutputSchema = AppRockskyChartsDefs.ChartsView
25
+
export type HandlerInput = undefined
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+71
apps/cli/src/lexicon/types/app/rocksky/dropbox/defs.ts
+71
apps/cli/src/lexicon/types/app/rocksky/dropbox/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface FileView {
10
+
/** The unique identifier of the file. */
11
+
id?: string
12
+
/** The name of the file. */
13
+
name?: string
14
+
/** The lowercased path of the file. */
15
+
pathLower?: string
16
+
/** The display path of the file. */
17
+
pathDisplay?: string
18
+
/** The last modified date and time of the file on the client. */
19
+
clientModified?: string
20
+
/** The last modified date and time of the file on the server. */
21
+
serverModified?: string
22
+
[k: string]: unknown
23
+
}
24
+
25
+
export function isFileView(v: unknown): v is FileView {
26
+
return (
27
+
isObj(v) &&
28
+
hasProp(v, '$type') &&
29
+
v.$type === 'app.rocksky.dropbox.defs#fileView'
30
+
)
31
+
}
32
+
33
+
export function validateFileView(v: unknown): ValidationResult {
34
+
return lexicons.validate('app.rocksky.dropbox.defs#fileView', v)
35
+
}
36
+
37
+
export interface FileListView {
38
+
/** A list of files in the Dropbox. */
39
+
files?: FileView[]
40
+
[k: string]: unknown
41
+
}
42
+
43
+
export function isFileListView(v: unknown): v is FileListView {
44
+
return (
45
+
isObj(v) &&
46
+
hasProp(v, '$type') &&
47
+
v.$type === 'app.rocksky.dropbox.defs#fileListView'
48
+
)
49
+
}
50
+
51
+
export function validateFileListView(v: unknown): ValidationResult {
52
+
return lexicons.validate('app.rocksky.dropbox.defs#fileListView', v)
53
+
}
54
+
55
+
export interface TemporaryLinkView {
56
+
/** The temporary link to access the file. */
57
+
link?: string
58
+
[k: string]: unknown
59
+
}
60
+
61
+
export function isTemporaryLinkView(v: unknown): v is TemporaryLinkView {
62
+
return (
63
+
isObj(v) &&
64
+
hasProp(v, '$type') &&
65
+
v.$type === 'app.rocksky.dropbox.defs#temporaryLinkView'
66
+
)
67
+
}
68
+
69
+
export function validateTemporaryLinkView(v: unknown): ValidationResult {
70
+
return lexicons.validate('app.rocksky.dropbox.defs#temporaryLinkView', v)
71
+
}
+42
apps/cli/src/lexicon/types/app/rocksky/dropbox/downloadFile.ts
+42
apps/cli/src/lexicon/types/app/rocksky/dropbox/downloadFile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import stream from 'stream'
6
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
7
+
import { lexicons } from '../../../../lexicons'
8
+
import { isObj, hasProp } from '../../../../util'
9
+
import { CID } from 'multiformats/cid'
10
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the file to download */
14
+
fileId: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type HandlerInput = undefined
19
+
20
+
export interface HandlerSuccess {
21
+
encoding: 'application/octet-stream'
22
+
body: Uint8Array | stream.Readable
23
+
headers?: { [key: string]: string }
24
+
}
25
+
26
+
export interface HandlerError {
27
+
status: number
28
+
message?: string
29
+
}
30
+
31
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
+
auth: HA
34
+
params: QueryParams
35
+
input: HandlerInput
36
+
req: express.Request
37
+
res: express.Response
38
+
resetRouteRateLimits: () => Promise<void>
39
+
}
40
+
export type Handler<HA extends HandlerAuth = never> = (
41
+
ctx: HandlerReqCtx<HA>,
42
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getFiles.ts
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getFiles.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyDropboxDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** Path to the Dropbox folder or root directory */
14
+
at?: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyDropboxDefs.FileListView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getMetadata.ts
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getMetadata.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyDropboxDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** Path to the file or folder in Dropbox */
14
+
path: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyDropboxDefs.FileView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getTemporaryLink.ts
+43
apps/cli/src/lexicon/types/app/rocksky/dropbox/getTemporaryLink.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyDropboxDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** Path to the file in Dropbox */
14
+
path: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyDropboxDefs.TemporaryLinkView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+182
apps/cli/src/lexicon/types/app/rocksky/feed/defs.ts
+182
apps/cli/src/lexicon/types/app/rocksky/feed/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskySongDefs from '../song/defs'
9
+
import * as AppRockskyAlbumDefs from '../album/defs'
10
+
import * as AppRockskyArtistDefs from '../artist/defs'
11
+
import * as AppRockskyPlaylistDefs from '../playlist/defs'
12
+
import * as AppRockskyActorDefs from '../actor/defs'
13
+
import * as AppRockskyScrobbleDefs from '../scrobble/defs'
14
+
15
+
export interface SearchResultsView {
16
+
hits?: (
17
+
| AppRockskySongDefs.SongViewBasic
18
+
| AppRockskyAlbumDefs.AlbumViewBasic
19
+
| AppRockskyArtistDefs.ArtistViewBasic
20
+
| AppRockskyPlaylistDefs.PlaylistViewBasic
21
+
| AppRockskyActorDefs.ProfileViewBasic
22
+
| { $type: string; [k: string]: unknown }
23
+
)[]
24
+
processingTimeMs?: number
25
+
limit?: number
26
+
offset?: number
27
+
estimatedTotalHits?: number
28
+
[k: string]: unknown
29
+
}
30
+
31
+
export function isSearchResultsView(v: unknown): v is SearchResultsView {
32
+
return (
33
+
isObj(v) &&
34
+
hasProp(v, '$type') &&
35
+
v.$type === 'app.rocksky.feed.defs#searchResultsView'
36
+
)
37
+
}
38
+
39
+
export function validateSearchResultsView(v: unknown): ValidationResult {
40
+
return lexicons.validate('app.rocksky.feed.defs#searchResultsView', v)
41
+
}
42
+
43
+
export interface NowPlayingView {
44
+
album?: string
45
+
albumArt?: string
46
+
albumArtist?: string
47
+
albumUri?: string
48
+
artist?: string
49
+
artistUri?: string
50
+
avatar?: string
51
+
createdAt?: string
52
+
did?: string
53
+
handle?: string
54
+
id?: string
55
+
title?: string
56
+
trackId?: string
57
+
trackUri?: string
58
+
uri?: string
59
+
[k: string]: unknown
60
+
}
61
+
62
+
export function isNowPlayingView(v: unknown): v is NowPlayingView {
63
+
return (
64
+
isObj(v) &&
65
+
hasProp(v, '$type') &&
66
+
v.$type === 'app.rocksky.feed.defs#nowPlayingView'
67
+
)
68
+
}
69
+
70
+
export function validateNowPlayingView(v: unknown): ValidationResult {
71
+
return lexicons.validate('app.rocksky.feed.defs#nowPlayingView', v)
72
+
}
73
+
74
+
export interface NowPlayingsView {
75
+
nowPlayings?: NowPlayingView[]
76
+
[k: string]: unknown
77
+
}
78
+
79
+
export function isNowPlayingsView(v: unknown): v is NowPlayingsView {
80
+
return (
81
+
isObj(v) &&
82
+
hasProp(v, '$type') &&
83
+
v.$type === 'app.rocksky.feed.defs#nowPlayingsView'
84
+
)
85
+
}
86
+
87
+
export function validateNowPlayingsView(v: unknown): ValidationResult {
88
+
return lexicons.validate('app.rocksky.feed.defs#nowPlayingsView', v)
89
+
}
90
+
91
+
export interface FeedGeneratorsView {
92
+
feeds?: FeedGeneratorView[]
93
+
[k: string]: unknown
94
+
}
95
+
96
+
export function isFeedGeneratorsView(v: unknown): v is FeedGeneratorsView {
97
+
return (
98
+
isObj(v) &&
99
+
hasProp(v, '$type') &&
100
+
v.$type === 'app.rocksky.feed.defs#feedGeneratorsView'
101
+
)
102
+
}
103
+
104
+
export function validateFeedGeneratorsView(v: unknown): ValidationResult {
105
+
return lexicons.validate('app.rocksky.feed.defs#feedGeneratorsView', v)
106
+
}
107
+
108
+
export interface FeedGeneratorView {
109
+
id?: string
110
+
name?: string
111
+
description?: string
112
+
uri?: string
113
+
avatar?: string
114
+
creator?: AppRockskyActorDefs.ProfileViewBasic
115
+
[k: string]: unknown
116
+
}
117
+
118
+
export function isFeedGeneratorView(v: unknown): v is FeedGeneratorView {
119
+
return (
120
+
isObj(v) &&
121
+
hasProp(v, '$type') &&
122
+
v.$type === 'app.rocksky.feed.defs#feedGeneratorView'
123
+
)
124
+
}
125
+
126
+
export function validateFeedGeneratorView(v: unknown): ValidationResult {
127
+
return lexicons.validate('app.rocksky.feed.defs#feedGeneratorView', v)
128
+
}
129
+
130
+
export interface FeedUriView {
131
+
/** The feed URI. */
132
+
uri?: string
133
+
[k: string]: unknown
134
+
}
135
+
136
+
export function isFeedUriView(v: unknown): v is FeedUriView {
137
+
return (
138
+
isObj(v) &&
139
+
hasProp(v, '$type') &&
140
+
v.$type === 'app.rocksky.feed.defs#feedUriView'
141
+
)
142
+
}
143
+
144
+
export function validateFeedUriView(v: unknown): ValidationResult {
145
+
return lexicons.validate('app.rocksky.feed.defs#feedUriView', v)
146
+
}
147
+
148
+
export interface FeedItemView {
149
+
scrobble?: AppRockskyScrobbleDefs.ScrobbleViewBasic
150
+
[k: string]: unknown
151
+
}
152
+
153
+
export function isFeedItemView(v: unknown): v is FeedItemView {
154
+
return (
155
+
isObj(v) &&
156
+
hasProp(v, '$type') &&
157
+
v.$type === 'app.rocksky.feed.defs#feedItemView'
158
+
)
159
+
}
160
+
161
+
export function validateFeedItemView(v: unknown): ValidationResult {
162
+
return lexicons.validate('app.rocksky.feed.defs#feedItemView', v)
163
+
}
164
+
165
+
export interface FeedView {
166
+
feed?: FeedItemView[]
167
+
/** The pagination cursor for the next set of results. */
168
+
cursor?: string
169
+
[k: string]: unknown
170
+
}
171
+
172
+
export function isFeedView(v: unknown): v is FeedView {
173
+
return (
174
+
isObj(v) &&
175
+
hasProp(v, '$type') &&
176
+
v.$type === 'app.rocksky.feed.defs#feedView'
177
+
)
178
+
}
179
+
180
+
export function validateFeedView(v: unknown): ValidationResult {
181
+
return lexicons.validate('app.rocksky.feed.defs#feedView', v)
182
+
}
+48
apps/cli/src/lexicon/types/app/rocksky/feed/describeFeedGenerator.ts
+48
apps/cli/src/lexicon/types/app/rocksky/feed/describeFeedGenerator.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export type InputSchema = undefined
15
+
16
+
export interface OutputSchema {
17
+
/** The DID of the feed generator. */
18
+
did?: string
19
+
/** List of feed URIs generated by this feed generator. */
20
+
feeds?: AppRockskyFeedDefs.FeedUriView[]
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+29
apps/cli/src/lexicon/types/app/rocksky/feed/generator.ts
+29
apps/cli/src/lexicon/types/app/rocksky/feed/generator.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Record {
10
+
did: string
11
+
avatar?: BlobRef
12
+
displayName: string
13
+
description?: string
14
+
createdAt: string
15
+
[k: string]: unknown
16
+
}
17
+
18
+
export function isRecord(v: unknown): v is Record {
19
+
return (
20
+
isObj(v) &&
21
+
hasProp(v, '$type') &&
22
+
(v.$type === 'app.rocksky.feed.generator#main' ||
23
+
v.$type === 'app.rocksky.feed.generator')
24
+
)
25
+
}
26
+
27
+
export function validateRecord(v: unknown): ValidationResult {
28
+
return lexicons.validate('app.rocksky.feed.generator#main', v)
29
+
}
+47
apps/cli/src/lexicon/types/app/rocksky/feed/getFeed.ts
+47
apps/cli/src/lexicon/types/app/rocksky/feed/getFeed.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The feed URI. */
14
+
feed: string
15
+
/** The maximum number of scrobbles to return */
16
+
limit?: number
17
+
/** The cursor for pagination */
18
+
cursor?: string
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
export type OutputSchema = AppRockskyFeedDefs.FeedView
23
+
export type HandlerInput = undefined
24
+
25
+
export interface HandlerSuccess {
26
+
encoding: 'application/json'
27
+
body: OutputSchema
28
+
headers?: { [key: string]: string }
29
+
}
30
+
31
+
export interface HandlerError {
32
+
status: number
33
+
message?: string
34
+
}
35
+
36
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
37
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
38
+
auth: HA
39
+
params: QueryParams
40
+
input: HandlerInput
41
+
req: express.Request
42
+
res: express.Response
43
+
resetRouteRateLimits: () => Promise<void>
44
+
}
45
+
export type Handler<HA extends HandlerAuth = never> = (
46
+
ctx: HandlerReqCtx<HA>,
47
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedGenerator.ts
+48
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedGenerator.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** AT-URI of the feed generator record. */
14
+
feed: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
view?: AppRockskyFeedDefs.FeedGeneratorView
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedGenerators.ts
+43
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedGenerators.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of feed generators to return. */
14
+
size?: number
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyFeedDefs.FeedGeneratorsView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+56
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedSkeleton.ts
+56
apps/cli/src/lexicon/types/app/rocksky/feed/getFeedSkeleton.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyScrobbleDefs from '../scrobble/defs'
11
+
12
+
export interface QueryParams {
13
+
/** The feed URI. */
14
+
feed: string
15
+
/** The maximum number of scrobbles to return */
16
+
limit?: number
17
+
/** The offset for pagination */
18
+
offset?: number
19
+
/** The pagination cursor. */
20
+
cursor?: string
21
+
}
22
+
23
+
export type InputSchema = undefined
24
+
25
+
export interface OutputSchema {
26
+
scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]
27
+
/** The pagination cursor for the next set of results. */
28
+
cursor?: string
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/feed/getNowPlayings.ts
+43
apps/cli/src/lexicon/types/app/rocksky/feed/getNowPlayings.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of now playing tracks to return. */
14
+
size?: number
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyFeedDefs.NowPlayingsView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/feed/search.ts
+43
apps/cli/src/lexicon/types/app/rocksky/feed/search.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyFeedDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The search query string */
14
+
query: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyFeedDefs.SearchResultsView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+42
apps/cli/src/lexicon/types/app/rocksky/googledrive/defs.ts
+42
apps/cli/src/lexicon/types/app/rocksky/googledrive/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface FileView {
10
+
/** The unique identifier of the file. */
11
+
id?: string
12
+
[k: string]: unknown
13
+
}
14
+
15
+
export function isFileView(v: unknown): v is FileView {
16
+
return (
17
+
isObj(v) &&
18
+
hasProp(v, '$type') &&
19
+
v.$type === 'app.rocksky.googledrive.defs#fileView'
20
+
)
21
+
}
22
+
23
+
export function validateFileView(v: unknown): ValidationResult {
24
+
return lexicons.validate('app.rocksky.googledrive.defs#fileView', v)
25
+
}
26
+
27
+
export interface FileListView {
28
+
files?: FileView[]
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export function isFileListView(v: unknown): v is FileListView {
33
+
return (
34
+
isObj(v) &&
35
+
hasProp(v, '$type') &&
36
+
v.$type === 'app.rocksky.googledrive.defs#fileListView'
37
+
)
38
+
}
39
+
40
+
export function validateFileListView(v: unknown): ValidationResult {
41
+
return lexicons.validate('app.rocksky.googledrive.defs#fileListView', v)
42
+
}
+42
apps/cli/src/lexicon/types/app/rocksky/googledrive/downloadFile.ts
+42
apps/cli/src/lexicon/types/app/rocksky/googledrive/downloadFile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import stream from 'stream'
6
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
7
+
import { lexicons } from '../../../../lexicons'
8
+
import { isObj, hasProp } from '../../../../util'
9
+
import { CID } from 'multiformats/cid'
10
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the file to download */
14
+
fileId: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type HandlerInput = undefined
19
+
20
+
export interface HandlerSuccess {
21
+
encoding: 'application/octet-stream'
22
+
body: Uint8Array | stream.Readable
23
+
headers?: { [key: string]: string }
24
+
}
25
+
26
+
export interface HandlerError {
27
+
status: number
28
+
message?: string
29
+
}
30
+
31
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
+
auth: HA
34
+
params: QueryParams
35
+
input: HandlerInput
36
+
req: express.Request
37
+
res: express.Response
38
+
resetRouteRateLimits: () => Promise<void>
39
+
}
40
+
export type Handler<HA extends HandlerAuth = never> = (
41
+
ctx: HandlerReqCtx<HA>,
42
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/googledrive/getFile.ts
+43
apps/cli/src/lexicon/types/app/rocksky/googledrive/getFile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyGoogledriveDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the file to retrieve */
14
+
fileId: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyGoogledriveDefs.FileView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/googledrive/getFiles.ts
+43
apps/cli/src/lexicon/types/app/rocksky/googledrive/getFiles.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyGoogledriveDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** Path to the Google Drive folder or root directory */
14
+
at?: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyGoogledriveDefs.FileListView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+47
apps/cli/src/lexicon/types/app/rocksky/graph/defs.ts
+47
apps/cli/src/lexicon/types/app/rocksky/graph/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
/** indicates that a handle or DID could not be resolved */
10
+
export interface NotFoundActor {
11
+
actor: string
12
+
notFound: boolean
13
+
[k: string]: unknown
14
+
}
15
+
16
+
export function isNotFoundActor(v: unknown): v is NotFoundActor {
17
+
return (
18
+
isObj(v) &&
19
+
hasProp(v, '$type') &&
20
+
v.$type === 'app.rocksky.graph.defs#notFoundActor'
21
+
)
22
+
}
23
+
24
+
export function validateNotFoundActor(v: unknown): ValidationResult {
25
+
return lexicons.validate('app.rocksky.graph.defs#notFoundActor', v)
26
+
}
27
+
28
+
export interface Relationship {
29
+
did: string
30
+
/** if the actor follows this DID, this is the AT-URI of the follow record */
31
+
following?: string
32
+
/** if the actor is followed by this DID, contains the AT-URI of the follow record */
33
+
followedBy?: string
34
+
[k: string]: unknown
35
+
}
36
+
37
+
export function isRelationship(v: unknown): v is Relationship {
38
+
return (
39
+
isObj(v) &&
40
+
hasProp(v, '$type') &&
41
+
v.$type === 'app.rocksky.graph.defs#relationship'
42
+
)
43
+
}
44
+
45
+
export function validateRelationship(v: unknown): ValidationResult {
46
+
return lexicons.validate('app.rocksky.graph.defs#relationship', v)
47
+
}
+28
apps/cli/src/lexicon/types/app/rocksky/graph/follow.ts
+28
apps/cli/src/lexicon/types/app/rocksky/graph/follow.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
9
+
10
+
export interface Record {
11
+
createdAt: string
12
+
subject: string
13
+
via?: ComAtprotoRepoStrongRef.Main
14
+
[k: string]: unknown
15
+
}
16
+
17
+
export function isRecord(v: unknown): v is Record {
18
+
return (
19
+
isObj(v) &&
20
+
hasProp(v, '$type') &&
21
+
(v.$type === 'app.rocksky.graph.follow#main' ||
22
+
v.$type === 'app.rocksky.graph.follow')
23
+
)
24
+
}
25
+
26
+
export function validateRecord(v: unknown): ValidationResult {
27
+
return lexicons.validate('app.rocksky.graph.follow#main', v)
28
+
}
+50
apps/cli/src/lexicon/types/app/rocksky/graph/followAccount.ts
+50
apps/cli/src/lexicon/types/app/rocksky/graph/followAccount.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from '../actor/defs'
11
+
12
+
export interface QueryParams {
13
+
account: string
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
18
+
export interface OutputSchema {
19
+
subject: AppRockskyActorDefs.ProfileViewBasic
20
+
followers: AppRockskyActorDefs.ProfileViewBasic[]
21
+
/** A cursor value to pass to subsequent calls to get the next page of results. */
22
+
cursor?: string
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+56
apps/cli/src/lexicon/types/app/rocksky/graph/getFollowers.ts
+56
apps/cli/src/lexicon/types/app/rocksky/graph/getFollowers.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from '../actor/defs'
11
+
12
+
export interface QueryParams {
13
+
actor: string
14
+
limit: number
15
+
/** If provided, filters the followers to only include those with DIDs in this list. */
16
+
dids?: string[]
17
+
cursor?: string
18
+
}
19
+
20
+
export type InputSchema = undefined
21
+
22
+
export interface OutputSchema {
23
+
subject: AppRockskyActorDefs.ProfileViewBasic
24
+
followers: AppRockskyActorDefs.ProfileViewBasic[]
25
+
/** A cursor value to pass to subsequent calls to get the next page of results. */
26
+
cursor?: string
27
+
/** The total number of followers. */
28
+
count?: number
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+56
apps/cli/src/lexicon/types/app/rocksky/graph/getFollows.ts
+56
apps/cli/src/lexicon/types/app/rocksky/graph/getFollows.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from '../actor/defs'
11
+
12
+
export interface QueryParams {
13
+
actor: string
14
+
limit: number
15
+
/** If provided, filters the follows to only include those with DIDs in this list. */
16
+
dids?: string[]
17
+
cursor?: string
18
+
}
19
+
20
+
export type InputSchema = undefined
21
+
22
+
export interface OutputSchema {
23
+
subject: AppRockskyActorDefs.ProfileViewBasic
24
+
follows: AppRockskyActorDefs.ProfileViewBasic[]
25
+
/** A cursor value to pass to subsequent calls to get the next page of results. */
26
+
cursor?: string
27
+
/** The total number of follows. */
28
+
count?: number
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export type HandlerInput = undefined
33
+
34
+
export interface HandlerSuccess {
35
+
encoding: 'application/json'
36
+
body: OutputSchema
37
+
headers?: { [key: string]: string }
38
+
}
39
+
40
+
export interface HandlerError {
41
+
status: number
42
+
message?: string
43
+
}
44
+
45
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
46
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
47
+
auth: HA
48
+
params: QueryParams
49
+
input: HandlerInput
50
+
req: express.Request
51
+
res: express.Response
52
+
resetRouteRateLimits: () => Promise<void>
53
+
}
54
+
export type Handler<HA extends HandlerAuth = never> = (
55
+
ctx: HandlerReqCtx<HA>,
56
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/graph/getKnownFollowers.ts
+52
apps/cli/src/lexicon/types/app/rocksky/graph/getKnownFollowers.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from '../actor/defs'
11
+
12
+
export interface QueryParams {
13
+
actor: string
14
+
limit: number
15
+
cursor?: string
16
+
}
17
+
18
+
export type InputSchema = undefined
19
+
20
+
export interface OutputSchema {
21
+
subject: AppRockskyActorDefs.ProfileViewBasic
22
+
followers: AppRockskyActorDefs.ProfileViewBasic[]
23
+
/** A cursor value to pass to subsequent calls to get the next page of results. */
24
+
cursor?: string
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+50
apps/cli/src/lexicon/types/app/rocksky/graph/unfollowAccount.ts
+50
apps/cli/src/lexicon/types/app/rocksky/graph/unfollowAccount.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyActorDefs from '../actor/defs'
11
+
12
+
export interface QueryParams {
13
+
account: string
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
18
+
export interface OutputSchema {
19
+
subject: AppRockskyActorDefs.ProfileViewBasic
20
+
followers: AppRockskyActorDefs.ProfileViewBasic[]
21
+
/** A cursor value to pass to subsequent calls to get the next page of results. */
22
+
cursor?: string
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+27
apps/cli/src/lexicon/types/app/rocksky/like.ts
+27
apps/cli/src/lexicon/types/app/rocksky/like.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef'
9
+
10
+
export interface Record {
11
+
/** The date when the like was created. */
12
+
createdAt: string
13
+
subject: ComAtprotoRepoStrongRef.Main
14
+
[k: string]: unknown
15
+
}
16
+
17
+
export function isRecord(v: unknown): v is Record {
18
+
return (
19
+
isObj(v) &&
20
+
hasProp(v, '$type') &&
21
+
(v.$type === 'app.rocksky.like#main' || v.$type === 'app.rocksky.like')
22
+
)
23
+
}
24
+
25
+
export function validateRecord(v: unknown): ValidationResult {
26
+
return lexicons.validate('app.rocksky.like#main', v)
27
+
}
+49
apps/cli/src/lexicon/types/app/rocksky/like/dislikeShout.ts
+49
apps/cli/src/lexicon/types/app/rocksky/like/dislikeShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from '../shout/defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the shout to dislike */
16
+
uri?: string
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
21
+
22
+
export interface HandlerInput {
23
+
encoding: 'application/json'
24
+
body: InputSchema
25
+
}
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+49
apps/cli/src/lexicon/types/app/rocksky/like/dislikeSong.ts
+49
apps/cli/src/lexicon/types/app/rocksky/like/dislikeSong.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the song to dislike */
16
+
uri?: string
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export type OutputSchema = AppRockskySongDefs.SongViewDetailed
21
+
22
+
export interface HandlerInput {
23
+
encoding: 'application/json'
24
+
body: InputSchema
25
+
}
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+49
apps/cli/src/lexicon/types/app/rocksky/like/likeShout.ts
+49
apps/cli/src/lexicon/types/app/rocksky/like/likeShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from '../shout/defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the shout to like */
16
+
uri?: string
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
21
+
22
+
export interface HandlerInput {
23
+
encoding: 'application/json'
24
+
body: InputSchema
25
+
}
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+49
apps/cli/src/lexicon/types/app/rocksky/like/likeSong.ts
+49
apps/cli/src/lexicon/types/app/rocksky/like/likeSong.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from '../song/defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the song to like */
16
+
uri?: string
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export type OutputSchema = AppRockskySongDefs.SongViewDetailed
21
+
22
+
export interface HandlerInput {
23
+
encoding: 'application/json'
24
+
body: InputSchema
25
+
}
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+40
apps/cli/src/lexicon/types/app/rocksky/player/addDirectoryToQueue.ts
+40
apps/cli/src/lexicon/types/app/rocksky/player/addDirectoryToQueue.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
/** The directory to add to the queue */
14
+
directory: string
15
+
/** Position in the queue to insert the directory at, defaults to the end if not specified */
16
+
position?: number
17
+
/** Whether to shuffle the added directory in the queue */
18
+
shuffle?: boolean
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
export type HandlerInput = undefined
23
+
24
+
export interface HandlerError {
25
+
status: number
26
+
message?: string
27
+
}
28
+
29
+
export type HandlerOutput = HandlerError | void
30
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
31
+
auth: HA
32
+
params: QueryParams
33
+
input: HandlerInput
34
+
req: express.Request
35
+
res: express.Response
36
+
resetRouteRateLimits: () => Promise<void>
37
+
}
38
+
export type Handler<HA extends HandlerAuth = never> = (
39
+
ctx: HandlerReqCtx<HA>,
40
+
) => Promise<HandlerOutput> | HandlerOutput
+39
apps/cli/src/lexicon/types/app/rocksky/player/addItemsToQueue.ts
+39
apps/cli/src/lexicon/types/app/rocksky/player/addItemsToQueue.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
items: string[]
14
+
/** Position in the queue to insert the items at, defaults to the end if not specified */
15
+
position?: number
16
+
/** Whether to shuffle the added items in the queue */
17
+
shuffle?: boolean
18
+
}
19
+
20
+
export type InputSchema = undefined
21
+
export type HandlerInput = undefined
22
+
23
+
export interface HandlerError {
24
+
status: number
25
+
message?: string
26
+
}
27
+
28
+
export type HandlerOutput = HandlerError | void
29
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
30
+
auth: HA
31
+
params: QueryParams
32
+
input: HandlerInput
33
+
req: express.Request
34
+
res: express.Response
35
+
resetRouteRateLimits: () => Promise<void>
36
+
}
37
+
export type Handler<HA extends HandlerAuth = never> = (
38
+
ctx: HandlerReqCtx<HA>,
39
+
) => Promise<HandlerOutput> | HandlerOutput
+57
apps/cli/src/lexicon/types/app/rocksky/player/defs.ts
+57
apps/cli/src/lexicon/types/app/rocksky/player/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskySongDefsSongViewBasic from '../song/defs/songViewBasic'
9
+
10
+
export interface CurrentlyPlayingViewDetailed {
11
+
/** The title of the currently playing track */
12
+
title?: string
13
+
[k: string]: unknown
14
+
}
15
+
16
+
export function isCurrentlyPlayingViewDetailed(
17
+
v: unknown,
18
+
): v is CurrentlyPlayingViewDetailed {
19
+
return (
20
+
isObj(v) &&
21
+
hasProp(v, '$type') &&
22
+
v.$type === 'app.rocksky.player.defs#currentlyPlayingViewDetailed'
23
+
)
24
+
}
25
+
26
+
export function validateCurrentlyPlayingViewDetailed(
27
+
v: unknown,
28
+
): ValidationResult {
29
+
return lexicons.validate(
30
+
'app.rocksky.player.defs#currentlyPlayingViewDetailed',
31
+
v,
32
+
)
33
+
}
34
+
35
+
export interface PlaybackQueueViewDetailed {
36
+
tracks?: AppRockskySongDefsSongViewBasic.Main[]
37
+
[k: string]: unknown
38
+
}
39
+
40
+
export function isPlaybackQueueViewDetailed(
41
+
v: unknown,
42
+
): v is PlaybackQueueViewDetailed {
43
+
return (
44
+
isObj(v) &&
45
+
hasProp(v, '$type') &&
46
+
v.$type === 'app.rocksky.player.defs#playbackQueueViewDetailed'
47
+
)
48
+
}
49
+
50
+
export function validatePlaybackQueueViewDetailed(
51
+
v: unknown,
52
+
): ValidationResult {
53
+
return lexicons.validate(
54
+
'app.rocksky.player.defs#playbackQueueViewDetailed',
55
+
v,
56
+
)
57
+
}
+44
apps/cli/src/lexicon/types/app/rocksky/player/getCurrentlyPlaying.ts
+44
apps/cli/src/lexicon/types/app/rocksky/player/getCurrentlyPlaying.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlayerDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
playerId?: string
14
+
/** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */
15
+
actor?: string
16
+
}
17
+
18
+
export type InputSchema = undefined
19
+
export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed
20
+
export type HandlerInput = undefined
21
+
22
+
export interface HandlerSuccess {
23
+
encoding: 'application/json'
24
+
body: OutputSchema
25
+
headers?: { [key: string]: string }
26
+
}
27
+
28
+
export interface HandlerError {
29
+
status: number
30
+
message?: string
31
+
}
32
+
33
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
34
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
35
+
auth: HA
36
+
params: QueryParams
37
+
input: HandlerInput
38
+
req: express.Request
39
+
res: express.Response
40
+
resetRouteRateLimits: () => Promise<void>
41
+
}
42
+
export type Handler<HA extends HandlerAuth = never> = (
43
+
ctx: HandlerReqCtx<HA>,
44
+
) => Promise<HandlerOutput> | HandlerOutput
+42
apps/cli/src/lexicon/types/app/rocksky/player/getPlaybackQueue.ts
+42
apps/cli/src/lexicon/types/app/rocksky/player/getPlaybackQueue.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlayerDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
playerId?: string
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
export type OutputSchema = AppRockskyPlayerDefs.PlaybackQueueViewDetailed
18
+
export type HandlerInput = undefined
19
+
20
+
export interface HandlerSuccess {
21
+
encoding: 'application/json'
22
+
body: OutputSchema
23
+
headers?: { [key: string]: string }
24
+
}
25
+
26
+
export interface HandlerError {
27
+
status: number
28
+
message?: string
29
+
}
30
+
31
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
32
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
33
+
auth: HA
34
+
params: QueryParams
35
+
input: HandlerInput
36
+
req: express.Request
37
+
res: express.Response
38
+
resetRouteRateLimits: () => Promise<void>
39
+
}
40
+
export type Handler<HA extends HandlerAuth = never> = (
41
+
ctx: HandlerReqCtx<HA>,
42
+
) => Promise<HandlerOutput> | HandlerOutput
+34
apps/cli/src/lexicon/types/app/rocksky/player/next.ts
+34
apps/cli/src/lexicon/types/app/rocksky/player/next.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
}
14
+
15
+
export type InputSchema = undefined
16
+
export type HandlerInput = undefined
17
+
18
+
export interface HandlerError {
19
+
status: number
20
+
message?: string
21
+
}
22
+
23
+
export type HandlerOutput = HandlerError | void
24
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
25
+
auth: HA
26
+
params: QueryParams
27
+
input: HandlerInput
28
+
req: express.Request
29
+
res: express.Response
30
+
resetRouteRateLimits: () => Promise<void>
31
+
}
32
+
export type Handler<HA extends HandlerAuth = never> = (
33
+
ctx: HandlerReqCtx<HA>,
34
+
) => Promise<HandlerOutput> | HandlerOutput
+34
apps/cli/src/lexicon/types/app/rocksky/player/pause.ts
+34
apps/cli/src/lexicon/types/app/rocksky/player/pause.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
}
14
+
15
+
export type InputSchema = undefined
16
+
export type HandlerInput = undefined
17
+
18
+
export interface HandlerError {
19
+
status: number
20
+
message?: string
21
+
}
22
+
23
+
export type HandlerOutput = HandlerError | void
24
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
25
+
auth: HA
26
+
params: QueryParams
27
+
input: HandlerInput
28
+
req: express.Request
29
+
res: express.Response
30
+
resetRouteRateLimits: () => Promise<void>
31
+
}
32
+
export type Handler<HA extends HandlerAuth = never> = (
33
+
ctx: HandlerReqCtx<HA>,
34
+
) => Promise<HandlerOutput> | HandlerOutput
+34
apps/cli/src/lexicon/types/app/rocksky/player/play.ts
+34
apps/cli/src/lexicon/types/app/rocksky/player/play.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
}
14
+
15
+
export type InputSchema = undefined
16
+
export type HandlerInput = undefined
17
+
18
+
export interface HandlerError {
19
+
status: number
20
+
message?: string
21
+
}
22
+
23
+
export type HandlerOutput = HandlerError | void
24
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
25
+
auth: HA
26
+
params: QueryParams
27
+
input: HandlerInput
28
+
req: express.Request
29
+
res: express.Response
30
+
resetRouteRateLimits: () => Promise<void>
31
+
}
32
+
export type Handler<HA extends HandlerAuth = never> = (
33
+
ctx: HandlerReqCtx<HA>,
34
+
) => Promise<HandlerOutput> | HandlerOutput
+38
apps/cli/src/lexicon/types/app/rocksky/player/playDirectory.ts
+38
apps/cli/src/lexicon/types/app/rocksky/player/playDirectory.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
directoryId: string
14
+
shuffle?: boolean
15
+
recurse?: boolean
16
+
position?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
export type HandlerInput = undefined
21
+
22
+
export interface HandlerError {
23
+
status: number
24
+
message?: string
25
+
}
26
+
27
+
export type HandlerOutput = HandlerError | void
28
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
29
+
auth: HA
30
+
params: QueryParams
31
+
input: HandlerInput
32
+
req: express.Request
33
+
res: express.Response
34
+
resetRouteRateLimits: () => Promise<void>
35
+
}
36
+
export type Handler<HA extends HandlerAuth = never> = (
37
+
ctx: HandlerReqCtx<HA>,
38
+
) => Promise<HandlerOutput> | HandlerOutput
+35
apps/cli/src/lexicon/types/app/rocksky/player/playFile.ts
+35
apps/cli/src/lexicon/types/app/rocksky/player/playFile.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
fileId: string
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
export type HandlerInput = undefined
18
+
19
+
export interface HandlerError {
20
+
status: number
21
+
message?: string
22
+
}
23
+
24
+
export type HandlerOutput = HandlerError | void
25
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
+
auth: HA
27
+
params: QueryParams
28
+
input: HandlerInput
29
+
req: express.Request
30
+
res: express.Response
31
+
resetRouteRateLimits: () => Promise<void>
32
+
}
33
+
export type Handler<HA extends HandlerAuth = never> = (
34
+
ctx: HandlerReqCtx<HA>,
35
+
) => Promise<HandlerOutput> | HandlerOutput
+34
apps/cli/src/lexicon/types/app/rocksky/player/previous.ts
+34
apps/cli/src/lexicon/types/app/rocksky/player/previous.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
}
14
+
15
+
export type InputSchema = undefined
16
+
export type HandlerInput = undefined
17
+
18
+
export interface HandlerError {
19
+
status: number
20
+
message?: string
21
+
}
22
+
23
+
export type HandlerOutput = HandlerError | void
24
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
25
+
auth: HA
26
+
params: QueryParams
27
+
input: HandlerInput
28
+
req: express.Request
29
+
res: express.Response
30
+
resetRouteRateLimits: () => Promise<void>
31
+
}
32
+
export type Handler<HA extends HandlerAuth = never> = (
33
+
ctx: HandlerReqCtx<HA>,
34
+
) => Promise<HandlerOutput> | HandlerOutput
+36
apps/cli/src/lexicon/types/app/rocksky/player/seek.ts
+36
apps/cli/src/lexicon/types/app/rocksky/player/seek.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
playerId?: string
13
+
/** The position in seconds to seek to */
14
+
position: number
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type HandlerInput = undefined
19
+
20
+
export interface HandlerError {
21
+
status: number
22
+
message?: string
23
+
}
24
+
25
+
export type HandlerOutput = HandlerError | void
26
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
27
+
auth: HA
28
+
params: QueryParams
29
+
input: HandlerInput
30
+
req: express.Request
31
+
res: express.Response
32
+
resetRouteRateLimits: () => Promise<void>
33
+
}
34
+
export type Handler<HA extends HandlerAuth = never> = (
35
+
ctx: HandlerReqCtx<HA>,
36
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/playlist.ts
+43
apps/cli/src/lexicon/types/app/rocksky/playlist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskySong from './song'
9
+
10
+
export interface Record {
11
+
/** The name of the playlist. */
12
+
name: string
13
+
/** The playlist description. */
14
+
description?: string
15
+
/** The picture of the playlist. */
16
+
picture?: BlobRef
17
+
/** The tracks in the playlist. */
18
+
tracks?: AppRockskySong.Record[]
19
+
/** The date the playlist was created. */
20
+
createdAt: string
21
+
/** The Spotify link of the playlist. */
22
+
spotifyLink?: string
23
+
/** The Tidal link of the playlist. */
24
+
tidalLink?: string
25
+
/** The YouTube link of the playlist. */
26
+
youtubeLink?: string
27
+
/** The Apple Music link of the playlist. */
28
+
appleMusicLink?: string
29
+
[k: string]: unknown
30
+
}
31
+
32
+
export function isRecord(v: unknown): v is Record {
33
+
return (
34
+
isObj(v) &&
35
+
hasProp(v, '$type') &&
36
+
(v.$type === 'app.rocksky.playlist#main' ||
37
+
v.$type === 'app.rocksky.playlist')
38
+
)
39
+
}
40
+
41
+
export function validateRecord(v: unknown): ValidationResult {
42
+
return lexicons.validate('app.rocksky.playlist#main', v)
43
+
}
+37
apps/cli/src/lexicon/types/app/rocksky/playlist/createPlaylist.ts
+37
apps/cli/src/lexicon/types/app/rocksky/playlist/createPlaylist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The name of the playlist */
13
+
name: string
14
+
/** A brief description of the playlist */
15
+
description?: string
16
+
}
17
+
18
+
export type InputSchema = undefined
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerError {
22
+
status: number
23
+
message?: string
24
+
}
25
+
26
+
export type HandlerOutput = HandlerError | void
27
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
28
+
auth: HA
29
+
params: QueryParams
30
+
input: HandlerInput
31
+
req: express.Request
32
+
res: express.Response
33
+
resetRouteRateLimits: () => Promise<void>
34
+
}
35
+
export type Handler<HA extends HandlerAuth = never> = (
36
+
ctx: HandlerReqCtx<HA>,
37
+
) => Promise<HandlerOutput> | HandlerOutput
+86
apps/cli/src/lexicon/types/app/rocksky/playlist/defs.ts
+86
apps/cli/src/lexicon/types/app/rocksky/playlist/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskySongDefs from '../song/defs'
9
+
10
+
/** Detailed view of a playlist, including its tracks and metadata */
11
+
export interface PlaylistViewDetailed {
12
+
/** The unique identifier of the playlist. */
13
+
id?: string
14
+
/** The title of the playlist. */
15
+
title?: string
16
+
/** The URI of the playlist. */
17
+
uri?: string
18
+
/** The DID of the curator of the playlist. */
19
+
curatorDid?: string
20
+
/** The handle of the curator of the playlist. */
21
+
curatorHandle?: string
22
+
/** The name of the curator of the playlist. */
23
+
curatorName?: string
24
+
/** The URL of the avatar image of the curator. */
25
+
curatorAvatarUrl?: string
26
+
/** A description of the playlist. */
27
+
description?: string
28
+
/** The URL of the cover image for the playlist. */
29
+
coverImageUrl?: string
30
+
/** The date and time when the playlist was created. */
31
+
createdAt?: string
32
+
/** A list of tracks in the playlist. */
33
+
tracks?: AppRockskySongDefs.SongViewBasic[]
34
+
[k: string]: unknown
35
+
}
36
+
37
+
export function isPlaylistViewDetailed(v: unknown): v is PlaylistViewDetailed {
38
+
return (
39
+
isObj(v) &&
40
+
hasProp(v, '$type') &&
41
+
v.$type === 'app.rocksky.playlist.defs#playlistViewDetailed'
42
+
)
43
+
}
44
+
45
+
export function validatePlaylistViewDetailed(v: unknown): ValidationResult {
46
+
return lexicons.validate('app.rocksky.playlist.defs#playlistViewDetailed', v)
47
+
}
48
+
49
+
/** Basic view of a playlist, including its metadata */
50
+
export interface PlaylistViewBasic {
51
+
/** The unique identifier of the playlist. */
52
+
id?: string
53
+
/** The title of the playlist. */
54
+
title?: string
55
+
/** The URI of the playlist. */
56
+
uri?: string
57
+
/** The DID of the curator of the playlist. */
58
+
curatorDid?: string
59
+
/** The handle of the curator of the playlist. */
60
+
curatorHandle?: string
61
+
/** The name of the curator of the playlist. */
62
+
curatorName?: string
63
+
/** The URL of the avatar image of the curator. */
64
+
curatorAvatarUrl?: string
65
+
/** A description of the playlist. */
66
+
description?: string
67
+
/** The URL of the cover image for the playlist. */
68
+
coverImageUrl?: string
69
+
/** The date and time when the playlist was created. */
70
+
createdAt?: string
71
+
/** The number of tracks in the playlist. */
72
+
trackCount?: number
73
+
[k: string]: unknown
74
+
}
75
+
76
+
export function isPlaylistViewBasic(v: unknown): v is PlaylistViewBasic {
77
+
return (
78
+
isObj(v) &&
79
+
hasProp(v, '$type') &&
80
+
v.$type === 'app.rocksky.playlist.defs#playlistViewBasic'
81
+
)
82
+
}
83
+
84
+
export function validatePlaylistViewBasic(v: unknown): ValidationResult {
85
+
return lexicons.validate('app.rocksky.playlist.defs#playlistViewBasic', v)
86
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/playlist/getPlaylist.ts
+43
apps/cli/src/lexicon/types/app/rocksky/playlist/getPlaylist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlaylistDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the playlist to retrieve. */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyPlaylistDefs.PlaylistViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+50
apps/cli/src/lexicon/types/app/rocksky/playlist/getPlaylists.ts
+50
apps/cli/src/lexicon/types/app/rocksky/playlist/getPlaylists.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlaylistDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of playlists to return. */
14
+
limit?: number
15
+
/** The offset for pagination, used to skip a number of playlists. */
16
+
offset?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
21
+
export interface OutputSchema {
22
+
playlists?: AppRockskyPlaylistDefs.PlaylistViewBasic[]
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+39
apps/cli/src/lexicon/types/app/rocksky/playlist/insertDirectory.ts
+39
apps/cli/src/lexicon/types/app/rocksky/playlist/insertDirectory.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The URI of the playlist to start */
13
+
uri: string
14
+
/** The directory (id) to insert into the playlist */
15
+
directory: string
16
+
/** The position in the playlist to insert the directory at, if not specified, the directory will be appended */
17
+
position?: number
18
+
}
19
+
20
+
export type InputSchema = undefined
21
+
export type HandlerInput = undefined
22
+
23
+
export interface HandlerError {
24
+
status: number
25
+
message?: string
26
+
}
27
+
28
+
export type HandlerOutput = HandlerError | void
29
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
30
+
auth: HA
31
+
params: QueryParams
32
+
input: HandlerInput
33
+
req: express.Request
34
+
res: express.Response
35
+
resetRouteRateLimits: () => Promise<void>
36
+
}
37
+
export type Handler<HA extends HandlerAuth = never> = (
38
+
ctx: HandlerReqCtx<HA>,
39
+
) => Promise<HandlerOutput> | HandlerOutput
+38
apps/cli/src/lexicon/types/app/rocksky/playlist/insertFiles.ts
+38
apps/cli/src/lexicon/types/app/rocksky/playlist/insertFiles.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The URI of the playlist to start */
13
+
uri: string
14
+
files: string[]
15
+
/** The position in the playlist to insert the files at, if not specified, files will be appended */
16
+
position?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
export type HandlerInput = undefined
21
+
22
+
export interface HandlerError {
23
+
status: number
24
+
message?: string
25
+
}
26
+
27
+
export type HandlerOutput = HandlerError | void
28
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
29
+
auth: HA
30
+
params: QueryParams
31
+
input: HandlerInput
32
+
req: express.Request
33
+
res: express.Response
34
+
resetRouteRateLimits: () => Promise<void>
35
+
}
36
+
export type Handler<HA extends HandlerAuth = never> = (
37
+
ctx: HandlerReqCtx<HA>,
38
+
) => Promise<HandlerOutput> | HandlerOutput
+35
apps/cli/src/lexicon/types/app/rocksky/playlist/removePlaylist.ts
+35
apps/cli/src/lexicon/types/app/rocksky/playlist/removePlaylist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The URI of the playlist to remove */
13
+
uri: string
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
export type HandlerInput = undefined
18
+
19
+
export interface HandlerError {
20
+
status: number
21
+
message?: string
22
+
}
23
+
24
+
export type HandlerOutput = HandlerError | void
25
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
+
auth: HA
27
+
params: QueryParams
28
+
input: HandlerInput
29
+
req: express.Request
30
+
res: express.Response
31
+
resetRouteRateLimits: () => Promise<void>
32
+
}
33
+
export type Handler<HA extends HandlerAuth = never> = (
34
+
ctx: HandlerReqCtx<HA>,
35
+
) => Promise<HandlerOutput> | HandlerOutput
+37
apps/cli/src/lexicon/types/app/rocksky/playlist/removeTrack.ts
+37
apps/cli/src/lexicon/types/app/rocksky/playlist/removeTrack.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The URI of the playlist to remove the track from */
13
+
uri: string
14
+
/** The position of the track to remove in the playlist */
15
+
position: number
16
+
}
17
+
18
+
export type InputSchema = undefined
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerError {
22
+
status: number
23
+
message?: string
24
+
}
25
+
26
+
export type HandlerOutput = HandlerError | void
27
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
28
+
auth: HA
29
+
params: QueryParams
30
+
input: HandlerInput
31
+
req: express.Request
32
+
res: express.Response
33
+
resetRouteRateLimits: () => Promise<void>
34
+
}
35
+
export type Handler<HA extends HandlerAuth = never> = (
36
+
ctx: HandlerReqCtx<HA>,
37
+
) => Promise<HandlerOutput> | HandlerOutput
+39
apps/cli/src/lexicon/types/app/rocksky/playlist/startPlaylist.ts
+39
apps/cli/src/lexicon/types/app/rocksky/playlist/startPlaylist.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The URI of the playlist to start */
13
+
uri: string
14
+
/** Whether to shuffle the playlist when starting it */
15
+
shuffle?: boolean
16
+
/** The position in the playlist to start from, if not specified, starts from the beginning */
17
+
position?: number
18
+
}
19
+
20
+
export type InputSchema = undefined
21
+
export type HandlerInput = undefined
22
+
23
+
export interface HandlerError {
24
+
status: number
25
+
message?: string
26
+
}
27
+
28
+
export type HandlerOutput = HandlerError | void
29
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
30
+
auth: HA
31
+
params: QueryParams
32
+
input: HandlerInput
33
+
req: express.Request
34
+
res: express.Response
35
+
resetRouteRateLimits: () => Promise<void>
36
+
}
37
+
export type Handler<HA extends HandlerAuth = never> = (
38
+
ctx: HandlerReqCtx<HA>,
39
+
) => Promise<HandlerOutput> | HandlerOutput
+37
apps/cli/src/lexicon/types/app/rocksky/radio.ts
+37
apps/cli/src/lexicon/types/app/rocksky/radio.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Record {
10
+
/** The name of the radio station. */
11
+
name: string
12
+
/** The URL of the radio station. */
13
+
url: string
14
+
/** A description of the radio station. */
15
+
description?: string
16
+
/** The genre of the radio station. */
17
+
genre?: string
18
+
/** The logo of the radio station. */
19
+
logo?: BlobRef
20
+
/** The website of the radio station. */
21
+
website?: string
22
+
/** The date when the radio station was created. */
23
+
createdAt: string
24
+
[k: string]: unknown
25
+
}
26
+
27
+
export function isRecord(v: unknown): v is Record {
28
+
return (
29
+
isObj(v) &&
30
+
hasProp(v, '$type') &&
31
+
(v.$type === 'app.rocksky.radio#main' || v.$type === 'app.rocksky.radio')
32
+
)
33
+
}
34
+
35
+
export function validateRecord(v: unknown): ValidationResult {
36
+
return lexicons.validate('app.rocksky.radio#main', v)
37
+
}
+63
apps/cli/src/lexicon/types/app/rocksky/radio/defs.ts
+63
apps/cli/src/lexicon/types/app/rocksky/radio/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface RadioViewBasic {
10
+
/** The unique identifier of the radio. */
11
+
id?: string
12
+
/** The name of the radio. */
13
+
name?: string
14
+
/** A brief description of the radio. */
15
+
description?: string
16
+
/** The date and time when the radio was created. */
17
+
createdAt?: string
18
+
[k: string]: unknown
19
+
}
20
+
21
+
export function isRadioViewBasic(v: unknown): v is RadioViewBasic {
22
+
return (
23
+
isObj(v) &&
24
+
hasProp(v, '$type') &&
25
+
v.$type === 'app.rocksky.radio.defs#radioViewBasic'
26
+
)
27
+
}
28
+
29
+
export function validateRadioViewBasic(v: unknown): ValidationResult {
30
+
return lexicons.validate('app.rocksky.radio.defs#radioViewBasic', v)
31
+
}
32
+
33
+
export interface RadioViewDetailed {
34
+
/** The unique identifier of the radio. */
35
+
id?: string
36
+
/** The name of the radio. */
37
+
name?: string
38
+
/** A brief description of the radio. */
39
+
description?: string
40
+
/** The website of the radio. */
41
+
website?: string
42
+
/** The streaming URL of the radio. */
43
+
url?: string
44
+
/** The genre of the radio. */
45
+
genre?: string
46
+
/** The logo of the radio station. */
47
+
logo?: string
48
+
/** The date and time when the radio was created. */
49
+
createdAt?: string
50
+
[k: string]: unknown
51
+
}
52
+
53
+
export function isRadioViewDetailed(v: unknown): v is RadioViewDetailed {
54
+
return (
55
+
isObj(v) &&
56
+
hasProp(v, '$type') &&
57
+
v.$type === 'app.rocksky.radio.defs#radioViewDetailed'
58
+
)
59
+
}
60
+
61
+
export function validateRadioViewDetailed(v: unknown): ValidationResult {
62
+
return lexicons.validate('app.rocksky.radio.defs#radioViewDetailed', v)
63
+
}
+75
apps/cli/src/lexicon/types/app/rocksky/scrobble.ts
+75
apps/cli/src/lexicon/types/app/rocksky/scrobble.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskyArtistDefs from './artist/defs'
9
+
10
+
export interface Record {
11
+
/** The title of the song. */
12
+
title: string
13
+
/** The artist of the song. */
14
+
artist: string
15
+
/** The artists of the song with MusicBrainz IDs. */
16
+
artists?: AppRockskyArtistDefs.ArtistMbid[]
17
+
/** The album artist of the song. */
18
+
albumArtist: string
19
+
/** The album of the song. */
20
+
album: string
21
+
/** The duration of the song in seconds. */
22
+
duration: number
23
+
/** The track number of the song in the album. */
24
+
trackNumber?: number
25
+
/** The disc number of the song in the album. */
26
+
discNumber?: number
27
+
/** The release date of the song. */
28
+
releaseDate?: string
29
+
/** The year the song was released. */
30
+
year?: number
31
+
/** The genre of the song. */
32
+
genre?: string
33
+
/** The tags of the song. */
34
+
tags?: string[]
35
+
/** The composer of the song. */
36
+
composer?: string
37
+
/** The lyrics of the song. */
38
+
lyrics?: string
39
+
/** The copyright message of the song. */
40
+
copyrightMessage?: string
41
+
/** Informations about the song */
42
+
wiki?: string
43
+
/** The album art of the song. */
44
+
albumArt?: BlobRef
45
+
/** The URL of the album art of the song. */
46
+
albumArtUrl?: string
47
+
/** The YouTube link of the song. */
48
+
youtubeLink?: string
49
+
/** The Spotify link of the song. */
50
+
spotifyLink?: string
51
+
/** The Tidal link of the song. */
52
+
tidalLink?: string
53
+
/** The Apple Music link of the song. */
54
+
appleMusicLink?: string
55
+
/** The date when the song was created. */
56
+
createdAt: string
57
+
/** The MusicBrainz ID of the song. */
58
+
mbid?: string
59
+
/** The label of the song. */
60
+
label?: string
61
+
[k: string]: unknown
62
+
}
63
+
64
+
export function isRecord(v: unknown): v is Record {
65
+
return (
66
+
isObj(v) &&
67
+
hasProp(v, '$type') &&
68
+
(v.$type === 'app.rocksky.scrobble#main' ||
69
+
v.$type === 'app.rocksky.scrobble')
70
+
)
71
+
}
72
+
73
+
export function validateRecord(v: unknown): ValidationResult {
74
+
return lexicons.validate('app.rocksky.scrobble#main', v)
75
+
}
+91
apps/cli/src/lexicon/types/app/rocksky/scrobble/createScrobble.ts
+91
apps/cli/src/lexicon/types/app/rocksky/scrobble/createScrobble.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyScrobbleDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The title of the track being scrobbled */
16
+
title: string
17
+
/** The artist of the track being scrobbled */
18
+
artist: string
19
+
/** The album of the track being scrobbled */
20
+
album?: string
21
+
/** The duration of the track in seconds */
22
+
duration?: number
23
+
/** The MusicBrainz ID of the track, if available */
24
+
mbId?: string
25
+
/** The URL of the album art for the track */
26
+
albumArt?: string
27
+
/** The track number of the track in the album */
28
+
trackNumber?: number
29
+
/** The release date of the track, formatted as YYYY-MM-DD */
30
+
releaseDate?: string
31
+
/** The year the track was released */
32
+
year?: number
33
+
/** The disc number of the track in the album, if applicable */
34
+
discNumber?: number
35
+
/** The lyrics of the track, if available */
36
+
lyrics?: string
37
+
/** The composer of the track, if available */
38
+
composer?: string
39
+
/** The copyright message for the track, if available */
40
+
copyrightMessage?: string
41
+
/** The record label of the track, if available */
42
+
label?: string
43
+
/** The URL of the artist's picture, if available */
44
+
artistPicture?: string
45
+
/** The Spotify link for the track, if available */
46
+
spotifyLink?: string
47
+
/** The Last.fm link for the track, if available */
48
+
lastfmLink?: string
49
+
/** The Tidal link for the track, if available */
50
+
tidalLink?: string
51
+
/** The Apple Music link for the track, if available */
52
+
appleMusicLink?: string
53
+
/** The Youtube link for the track, if available */
54
+
youtubeLink?: string
55
+
/** The Deezer link for the track, if available */
56
+
deezerLink?: string
57
+
/** The timestamp of the scrobble in milliseconds since epoch */
58
+
timestamp?: number
59
+
[k: string]: unknown
60
+
}
61
+
62
+
export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewBasic
63
+
64
+
export interface HandlerInput {
65
+
encoding: 'application/json'
66
+
body: InputSchema
67
+
}
68
+
69
+
export interface HandlerSuccess {
70
+
encoding: 'application/json'
71
+
body: OutputSchema
72
+
headers?: { [key: string]: string }
73
+
}
74
+
75
+
export interface HandlerError {
76
+
status: number
77
+
message?: string
78
+
}
79
+
80
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
81
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
82
+
auth: HA
83
+
params: QueryParams
84
+
input: HandlerInput
85
+
req: express.Request
86
+
res: express.Response
87
+
resetRouteRateLimits: () => Promise<void>
88
+
}
89
+
export type Handler<HA extends HandlerAuth = never> = (
90
+
ctx: HandlerReqCtx<HA>,
91
+
) => Promise<HandlerOutput> | HandlerOutput
+93
apps/cli/src/lexicon/types/app/rocksky/scrobble/defs.ts
+93
apps/cli/src/lexicon/types/app/rocksky/scrobble/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface ScrobbleViewBasic {
10
+
/** The unique identifier of the scrobble. */
11
+
id?: string
12
+
/** The handle of the user who created the scrobble. */
13
+
user?: string
14
+
/** The display name of the user who created the scrobble. */
15
+
userDisplayName?: string
16
+
/** The avatar URL of the user who created the scrobble. */
17
+
userAvatar?: string
18
+
/** The title of the scrobble. */
19
+
title?: string
20
+
/** The artist of the song. */
21
+
artist?: string
22
+
/** The URI of the artist. */
23
+
artistUri?: string
24
+
/** The album of the song. */
25
+
album?: string
26
+
/** The URI of the album. */
27
+
albumUri?: string
28
+
/** The album art URL of the song. */
29
+
cover?: string
30
+
/** The timestamp when the scrobble was created. */
31
+
date?: string
32
+
/** The URI of the scrobble. */
33
+
uri?: string
34
+
/** The SHA256 hash of the scrobble data. */
35
+
sha256?: string
36
+
liked?: boolean
37
+
likesCount?: number
38
+
[k: string]: unknown
39
+
}
40
+
41
+
export function isScrobbleViewBasic(v: unknown): v is ScrobbleViewBasic {
42
+
return (
43
+
isObj(v) &&
44
+
hasProp(v, '$type') &&
45
+
v.$type === 'app.rocksky.scrobble.defs#scrobbleViewBasic'
46
+
)
47
+
}
48
+
49
+
export function validateScrobbleViewBasic(v: unknown): ValidationResult {
50
+
return lexicons.validate('app.rocksky.scrobble.defs#scrobbleViewBasic', v)
51
+
}
52
+
53
+
export interface ScrobbleViewDetailed {
54
+
/** The unique identifier of the scrobble. */
55
+
id?: string
56
+
/** The handle of the user who created the scrobble. */
57
+
user?: string
58
+
/** The title of the scrobble. */
59
+
title?: string
60
+
/** The artist of the song. */
61
+
artist?: string
62
+
/** The URI of the artist. */
63
+
artistUri?: string
64
+
/** The album of the song. */
65
+
album?: string
66
+
/** The URI of the album. */
67
+
albumUri?: string
68
+
/** The album art URL of the song. */
69
+
cover?: string
70
+
/** The timestamp when the scrobble was created. */
71
+
date?: string
72
+
/** The URI of the scrobble. */
73
+
uri?: string
74
+
/** The SHA256 hash of the scrobble data. */
75
+
sha256?: string
76
+
/** The number of listeners */
77
+
listeners?: number
78
+
/** The number of scrobbles for this song */
79
+
scrobbles?: number
80
+
[k: string]: unknown
81
+
}
82
+
83
+
export function isScrobbleViewDetailed(v: unknown): v is ScrobbleViewDetailed {
84
+
return (
85
+
isObj(v) &&
86
+
hasProp(v, '$type') &&
87
+
v.$type === 'app.rocksky.scrobble.defs#scrobbleViewDetailed'
88
+
)
89
+
}
90
+
91
+
export function validateScrobbleViewDetailed(v: unknown): ValidationResult {
92
+
return lexicons.validate('app.rocksky.scrobble.defs#scrobbleViewDetailed', v)
93
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/scrobble/getScrobble.ts
+43
apps/cli/src/lexicon/types/app/rocksky/scrobble/getScrobble.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyScrobbleDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the scrobble */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyScrobbleDefs.ScrobbleViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+54
apps/cli/src/lexicon/types/app/rocksky/scrobble/getScrobbles.ts
+54
apps/cli/src/lexicon/types/app/rocksky/scrobble/getScrobbles.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyScrobbleDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did?: string
15
+
/** If true, only return scrobbles from actors the viewer is following. */
16
+
following?: boolean
17
+
/** The maximum number of scrobbles to return */
18
+
limit?: number
19
+
/** The offset for pagination */
20
+
offset?: number
21
+
}
22
+
23
+
export type InputSchema = undefined
24
+
25
+
export interface OutputSchema {
26
+
scrobbles?: AppRockskyScrobbleDefs.ScrobbleViewBasic[]
27
+
[k: string]: unknown
28
+
}
29
+
30
+
export type HandlerInput = undefined
31
+
32
+
export interface HandlerSuccess {
33
+
encoding: 'application/json'
34
+
body: OutputSchema
35
+
headers?: { [key: string]: string }
36
+
}
37
+
38
+
export interface HandlerError {
39
+
status: number
40
+
message?: string
41
+
}
42
+
43
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
44
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
45
+
auth: HA
46
+
params: QueryParams
47
+
input: HandlerInput
48
+
req: express.Request
49
+
res: express.Response
50
+
resetRouteRateLimits: () => Promise<void>
51
+
}
52
+
export type Handler<HA extends HandlerAuth = never> = (
53
+
ctx: HandlerReqCtx<HA>,
54
+
) => Promise<HandlerOutput> | HandlerOutput
+30
apps/cli/src/lexicon/types/app/rocksky/shout.ts
+30
apps/cli/src/lexicon/types/app/rocksky/shout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef'
9
+
10
+
export interface Record {
11
+
/** The message of the shout. */
12
+
message: string
13
+
/** The date when the shout was created. */
14
+
createdAt: string
15
+
parent?: ComAtprotoRepoStrongRef.Main
16
+
subject: ComAtprotoRepoStrongRef.Main
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export function isRecord(v: unknown): v is Record {
21
+
return (
22
+
isObj(v) &&
23
+
hasProp(v, '$type') &&
24
+
(v.$type === 'app.rocksky.shout#main' || v.$type === 'app.rocksky.shout')
25
+
)
26
+
}
27
+
28
+
export function validateRecord(v: unknown): ValidationResult {
29
+
return lexicons.validate('app.rocksky.shout#main', v)
30
+
}
+49
apps/cli/src/lexicon/types/app/rocksky/shout/createShout.ts
+49
apps/cli/src/lexicon/types/app/rocksky/shout/createShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The content of the shout */
16
+
message?: string
17
+
[k: string]: unknown
18
+
}
19
+
20
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
21
+
22
+
export interface HandlerInput {
23
+
encoding: 'application/json'
24
+
body: InputSchema
25
+
}
26
+
27
+
export interface HandlerSuccess {
28
+
encoding: 'application/json'
29
+
body: OutputSchema
30
+
headers?: { [key: string]: string }
31
+
}
32
+
33
+
export interface HandlerError {
34
+
status: number
35
+
message?: string
36
+
}
37
+
38
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
39
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
40
+
auth: HA
41
+
params: QueryParams
42
+
input: HandlerInput
43
+
req: express.Request
44
+
res: express.Response
45
+
resetRouteRateLimits: () => Promise<void>
46
+
}
47
+
export type Handler<HA extends HandlerAuth = never> = (
48
+
ctx: HandlerReqCtx<HA>,
49
+
) => Promise<HandlerOutput> | HandlerOutput
+58
apps/cli/src/lexicon/types/app/rocksky/shout/defs.ts
+58
apps/cli/src/lexicon/types/app/rocksky/shout/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Author {
10
+
/** The unique identifier of the author. */
11
+
id?: string
12
+
/** The decentralized identifier (DID) of the author. */
13
+
did?: string
14
+
/** The handle of the author. */
15
+
handle?: string
16
+
/** The display name of the author. */
17
+
displayName?: string
18
+
/** The URL of the author's avatar image. */
19
+
avatar?: string
20
+
[k: string]: unknown
21
+
}
22
+
23
+
export function isAuthor(v: unknown): v is Author {
24
+
return (
25
+
isObj(v) &&
26
+
hasProp(v, '$type') &&
27
+
v.$type === 'app.rocksky.shout.defs#author'
28
+
)
29
+
}
30
+
31
+
export function validateAuthor(v: unknown): ValidationResult {
32
+
return lexicons.validate('app.rocksky.shout.defs#author', v)
33
+
}
34
+
35
+
export interface ShoutView {
36
+
/** The unique identifier of the shout. */
37
+
id?: string
38
+
/** The content of the shout. */
39
+
message?: string
40
+
/** The ID of the parent shout if this is a reply, otherwise null. */
41
+
parent?: string
42
+
/** The date and time when the shout was created. */
43
+
createdAt?: string
44
+
author?: Author
45
+
[k: string]: unknown
46
+
}
47
+
48
+
export function isShoutView(v: unknown): v is ShoutView {
49
+
return (
50
+
isObj(v) &&
51
+
hasProp(v, '$type') &&
52
+
v.$type === 'app.rocksky.shout.defs#shoutView'
53
+
)
54
+
}
55
+
56
+
export function validateShoutView(v: unknown): ValidationResult {
57
+
return lexicons.validate('app.rocksky.shout.defs#shoutView', v)
58
+
}
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getAlbumShouts.ts
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getAlbumShouts.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the album to retrieve shouts for */
14
+
uri: string
15
+
/** The maximum number of shouts to return */
16
+
limit?: number
17
+
/** The number of shouts to skip before starting to collect the result set */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getArtistShouts.ts
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getArtistShouts.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the artist to retrieve shouts for */
14
+
uri: string
15
+
/** The maximum number of shouts to return */
16
+
limit?: number
17
+
/** The number of shouts to skip before starting to collect the result set */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getProfileShouts.ts
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getProfileShouts.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the actor */
14
+
did: string
15
+
/** The offset for pagination */
16
+
offset?: number
17
+
/** The maximum number of shouts to return */
18
+
limit?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getShoutReplies.ts
+52
apps/cli/src/lexicon/types/app/rocksky/shout/getShoutReplies.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the shout to retrieve replies for */
14
+
uri: string
15
+
/** The maximum number of shouts to return */
16
+
limit?: number
17
+
/** The number of shouts to skip before starting to collect the result set */
18
+
offset?: number
19
+
}
20
+
21
+
export type InputSchema = undefined
22
+
23
+
export interface OutputSchema {
24
+
shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
25
+
[k: string]: unknown
26
+
}
27
+
28
+
export type HandlerInput = undefined
29
+
30
+
export interface HandlerSuccess {
31
+
encoding: 'application/json'
32
+
body: OutputSchema
33
+
headers?: { [key: string]: string }
34
+
}
35
+
36
+
export interface HandlerError {
37
+
status: number
38
+
message?: string
39
+
}
40
+
41
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
42
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
43
+
auth: HA
44
+
params: QueryParams
45
+
input: HandlerInput
46
+
req: express.Request
47
+
res: express.Response
48
+
resetRouteRateLimits: () => Promise<void>
49
+
}
50
+
export type Handler<HA extends HandlerAuth = never> = (
51
+
ctx: HandlerReqCtx<HA>,
52
+
) => Promise<HandlerOutput> | HandlerOutput
+48
apps/cli/src/lexicon/types/app/rocksky/shout/getTrackShouts.ts
+48
apps/cli/src/lexicon/types/app/rocksky/shout/getTrackShouts.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The URI of the track to retrieve shouts for */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
19
+
export interface OutputSchema {
20
+
shouts?: AppRockskyShoutDefs.ShoutViewBasic[]
21
+
[k: string]: unknown
22
+
}
23
+
24
+
export type HandlerInput = undefined
25
+
26
+
export interface HandlerSuccess {
27
+
encoding: 'application/json'
28
+
body: OutputSchema
29
+
headers?: { [key: string]: string }
30
+
}
31
+
32
+
export interface HandlerError {
33
+
status: number
34
+
message?: string
35
+
}
36
+
37
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
38
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
39
+
auth: HA
40
+
params: QueryParams
41
+
input: HandlerInput
42
+
req: express.Request
43
+
res: express.Response
44
+
resetRouteRateLimits: () => Promise<void>
45
+
}
46
+
export type Handler<HA extends HandlerAuth = never> = (
47
+
ctx: HandlerReqCtx<HA>,
48
+
) => Promise<HandlerOutput> | HandlerOutput
+43
apps/cli/src/lexicon/types/app/rocksky/shout/removeShout.ts
+43
apps/cli/src/lexicon/types/app/rocksky/shout/removeShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The ID of the shout to be removed */
14
+
id: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+51
apps/cli/src/lexicon/types/app/rocksky/shout/replyShout.ts
+51
apps/cli/src/lexicon/types/app/rocksky/shout/replyShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the shout to reply to */
16
+
shoutId: string
17
+
/** The content of the reply */
18
+
message: string
19
+
[k: string]: unknown
20
+
}
21
+
22
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
23
+
24
+
export interface HandlerInput {
25
+
encoding: 'application/json'
26
+
body: InputSchema
27
+
}
28
+
29
+
export interface HandlerSuccess {
30
+
encoding: 'application/json'
31
+
body: OutputSchema
32
+
headers?: { [key: string]: string }
33
+
}
34
+
35
+
export interface HandlerError {
36
+
status: number
37
+
message?: string
38
+
}
39
+
40
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
41
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
42
+
auth: HA
43
+
params: QueryParams
44
+
input: HandlerInput
45
+
req: express.Request
46
+
res: express.Response
47
+
resetRouteRateLimits: () => Promise<void>
48
+
}
49
+
export type Handler<HA extends HandlerAuth = never> = (
50
+
ctx: HandlerReqCtx<HA>,
51
+
) => Promise<HandlerOutput> | HandlerOutput
+51
apps/cli/src/lexicon/types/app/rocksky/shout/reportShout.ts
+51
apps/cli/src/lexicon/types/app/rocksky/shout/reportShout.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyShoutDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The unique identifier of the shout to report */
16
+
shoutId: string
17
+
/** The reason for reporting the shout */
18
+
reason?: string
19
+
[k: string]: unknown
20
+
}
21
+
22
+
export type OutputSchema = AppRockskyShoutDefs.ShoutView
23
+
24
+
export interface HandlerInput {
25
+
encoding: 'application/json'
26
+
body: InputSchema
27
+
}
28
+
29
+
export interface HandlerSuccess {
30
+
encoding: 'application/json'
31
+
body: OutputSchema
32
+
headers?: { [key: string]: string }
33
+
}
34
+
35
+
export interface HandlerError {
36
+
status: number
37
+
message?: string
38
+
}
39
+
40
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
41
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
42
+
auth: HA
43
+
params: QueryParams
44
+
input: HandlerInput
45
+
req: express.Request
46
+
res: express.Response
47
+
resetRouteRateLimits: () => Promise<void>
48
+
}
49
+
export type Handler<HA extends HandlerAuth = never> = (
50
+
ctx: HandlerReqCtx<HA>,
51
+
) => Promise<HandlerOutput> | HandlerOutput
+74
apps/cli/src/lexicon/types/app/rocksky/song.ts
+74
apps/cli/src/lexicon/types/app/rocksky/song.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../lexicons'
6
+
import { isObj, hasProp } from '../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
import * as AppRockskyArtistDefs from './artist/defs'
9
+
10
+
export interface Record {
11
+
/** The title of the song. */
12
+
title: string
13
+
/** The artist of the song. */
14
+
artist: string
15
+
/** The artists of the song with MusicBrainz IDs. */
16
+
artists?: AppRockskyArtistDefs.ArtistMbid[]
17
+
/** The album artist of the song. */
18
+
albumArtist: string
19
+
/** The album of the song. */
20
+
album: string
21
+
/** The duration of the song in seconds. */
22
+
duration: number
23
+
/** The track number of the song in the album. */
24
+
trackNumber?: number
25
+
/** The disc number of the song in the album. */
26
+
discNumber?: number
27
+
/** The release date of the song. */
28
+
releaseDate?: string
29
+
/** The year the song was released. */
30
+
year?: number
31
+
/** The genre of the song. */
32
+
genre?: string
33
+
/** The tags of the song. */
34
+
tags?: string[]
35
+
/** The composer of the song. */
36
+
composer?: string
37
+
/** The lyrics of the song. */
38
+
lyrics?: string
39
+
/** The copyright message of the song. */
40
+
copyrightMessage?: string
41
+
/** Informations about the song */
42
+
wiki?: string
43
+
/** The album art of the song. */
44
+
albumArt?: BlobRef
45
+
/** The URL of the album art of the song. */
46
+
albumArtUrl?: string
47
+
/** The YouTube link of the song. */
48
+
youtubeLink?: string
49
+
/** The Spotify link of the song. */
50
+
spotifyLink?: string
51
+
/** The Tidal link of the song. */
52
+
tidalLink?: string
53
+
/** The Apple Music link of the song. */
54
+
appleMusicLink?: string
55
+
/** The date when the song was created. */
56
+
createdAt: string
57
+
/** The MusicBrainz ID of the song. */
58
+
mbid?: string
59
+
/** The label of the song. */
60
+
label?: string
61
+
[k: string]: unknown
62
+
}
63
+
64
+
export function isRecord(v: unknown): v is Record {
65
+
return (
66
+
isObj(v) &&
67
+
hasProp(v, '$type') &&
68
+
(v.$type === 'app.rocksky.song#main' || v.$type === 'app.rocksky.song')
69
+
)
70
+
}
71
+
72
+
export function validateRecord(v: unknown): ValidationResult {
73
+
return lexicons.validate('app.rocksky.song#main', v)
74
+
}
+71
apps/cli/src/lexicon/types/app/rocksky/song/createSong.ts
+71
apps/cli/src/lexicon/types/app/rocksky/song/createSong.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from './defs'
11
+
12
+
export interface QueryParams {}
13
+
14
+
export interface InputSchema {
15
+
/** The title of the song */
16
+
title: string
17
+
/** The artist of the song */
18
+
artist: string
19
+
/** The album artist of the song, if different from the main artist */
20
+
albumArtist: string
21
+
/** The album of the song, if applicable */
22
+
album: string
23
+
/** The duration of the song in seconds */
24
+
duration?: number
25
+
/** The MusicBrainz ID of the song, if available */
26
+
mbId?: string
27
+
/** The URL of the album art for the song */
28
+
albumArt?: string
29
+
/** The track number of the song in the album, if applicable */
30
+
trackNumber?: number
31
+
/** The release date of the song, formatted as YYYY-MM-DD */
32
+
releaseDate?: string
33
+
/** The year the song was released */
34
+
year?: number
35
+
/** The disc number of the song in the album, if applicable */
36
+
discNumber?: number
37
+
/** The lyrics of the song, if available */
38
+
lyrics?: string
39
+
[k: string]: unknown
40
+
}
41
+
42
+
export type OutputSchema = AppRockskySongDefs.SongViewDetailed
43
+
44
+
export interface HandlerInput {
45
+
encoding: 'application/json'
46
+
body: InputSchema
47
+
}
48
+
49
+
export interface HandlerSuccess {
50
+
encoding: 'application/json'
51
+
body: OutputSchema
52
+
headers?: { [key: string]: string }
53
+
}
54
+
55
+
export interface HandlerError {
56
+
status: number
57
+
message?: string
58
+
}
59
+
60
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
61
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
62
+
auth: HA
63
+
params: QueryParams
64
+
input: HandlerInput
65
+
req: express.Request
66
+
res: express.Response
67
+
resetRouteRateLimits: () => Promise<void>
68
+
}
69
+
export type Handler<HA extends HandlerAuth = never> = (
70
+
ctx: HandlerReqCtx<HA>,
71
+
) => Promise<HandlerOutput> | HandlerOutput
+103
apps/cli/src/lexicon/types/app/rocksky/song/defs.ts
+103
apps/cli/src/lexicon/types/app/rocksky/song/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface SongViewBasic {
10
+
/** The unique identifier of the song. */
11
+
id?: string
12
+
/** The title of the song. */
13
+
title?: string
14
+
/** The artist of the song. */
15
+
artist?: string
16
+
/** The artist of the album the song belongs to. */
17
+
albumArtist?: string
18
+
/** The URL of the album art image. */
19
+
albumArt?: string
20
+
/** The URI of the song. */
21
+
uri?: string
22
+
/** The album of the song. */
23
+
album?: string
24
+
/** The duration of the song in milliseconds. */
25
+
duration?: number
26
+
/** The track number of the song in the album. */
27
+
trackNumber?: number
28
+
/** The disc number of the song in the album. */
29
+
discNumber?: number
30
+
/** The number of times the song has been played. */
31
+
playCount?: number
32
+
/** The number of unique listeners who have played the song. */
33
+
uniqueListeners?: number
34
+
/** The URI of the album the song belongs to. */
35
+
albumUri?: string
36
+
/** The URI of the artist of the song. */
37
+
artistUri?: string
38
+
/** The SHA256 hash of the song. */
39
+
sha256?: string
40
+
/** The timestamp when the song was created. */
41
+
createdAt?: string
42
+
[k: string]: unknown
43
+
}
44
+
45
+
export function isSongViewBasic(v: unknown): v is SongViewBasic {
46
+
return (
47
+
isObj(v) &&
48
+
hasProp(v, '$type') &&
49
+
v.$type === 'app.rocksky.song.defs#songViewBasic'
50
+
)
51
+
}
52
+
53
+
export function validateSongViewBasic(v: unknown): ValidationResult {
54
+
return lexicons.validate('app.rocksky.song.defs#songViewBasic', v)
55
+
}
56
+
57
+
export interface SongViewDetailed {
58
+
/** The unique identifier of the song. */
59
+
id?: string
60
+
/** The title of the song. */
61
+
title?: string
62
+
/** The artist of the song. */
63
+
artist?: string
64
+
/** The artist of the album the song belongs to. */
65
+
albumArtist?: string
66
+
/** The URL of the album art image. */
67
+
albumArt?: string
68
+
/** The URI of the song. */
69
+
uri?: string
70
+
/** The album of the song. */
71
+
album?: string
72
+
/** The duration of the song in milliseconds. */
73
+
duration?: number
74
+
/** The track number of the song in the album. */
75
+
trackNumber?: number
76
+
/** The disc number of the song in the album. */
77
+
discNumber?: number
78
+
/** The number of times the song has been played. */
79
+
playCount?: number
80
+
/** The number of unique listeners who have played the song. */
81
+
uniqueListeners?: number
82
+
/** The URI of the album the song belongs to. */
83
+
albumUri?: string
84
+
/** The URI of the artist of the song. */
85
+
artistUri?: string
86
+
/** The SHA256 hash of the song. */
87
+
sha256?: string
88
+
/** The timestamp when the song was created. */
89
+
createdAt?: string
90
+
[k: string]: unknown
91
+
}
92
+
93
+
export function isSongViewDetailed(v: unknown): v is SongViewDetailed {
94
+
return (
95
+
isObj(v) &&
96
+
hasProp(v, '$type') &&
97
+
v.$type === 'app.rocksky.song.defs#songViewDetailed'
98
+
)
99
+
}
100
+
101
+
export function validateSongViewDetailed(v: unknown): ValidationResult {
102
+
return lexicons.validate('app.rocksky.song.defs#songViewDetailed', v)
103
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/song/getSong.ts
+43
apps/cli/src/lexicon/types/app/rocksky/song/getSong.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The unique identifier of the song to retrieve */
14
+
uri: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskySongDefs.SongViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+50
apps/cli/src/lexicon/types/app/rocksky/song/getSongs.ts
+50
apps/cli/src/lexicon/types/app/rocksky/song/getSongs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskySongDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The maximum number of songs to return */
14
+
limit?: number
15
+
/** The offset for pagination */
16
+
offset?: number
17
+
}
18
+
19
+
export type InputSchema = undefined
20
+
21
+
export interface OutputSchema {
22
+
songs?: AppRockskySongDefs.SongViewBasic[]
23
+
[k: string]: unknown
24
+
}
25
+
26
+
export type HandlerInput = undefined
27
+
28
+
export interface HandlerSuccess {
29
+
encoding: 'application/json'
30
+
body: OutputSchema
31
+
headers?: { [key: string]: string }
32
+
}
33
+
34
+
export interface HandlerError {
35
+
status: number
36
+
message?: string
37
+
}
38
+
39
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
40
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
41
+
auth: HA
42
+
params: QueryParams
43
+
input: HandlerInput
44
+
req: express.Request
45
+
res: express.Response
46
+
resetRouteRateLimits: () => Promise<void>
47
+
}
48
+
export type Handler<HA extends HandlerAuth = never> = (
49
+
ctx: HandlerReqCtx<HA>,
50
+
) => Promise<HandlerOutput> | HandlerOutput
+35
apps/cli/src/lexicon/types/app/rocksky/spotify/defs.ts
+35
apps/cli/src/lexicon/types/app/rocksky/spotify/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface SpotifyTrackView {
10
+
/** The unique identifier of the Spotify track. */
11
+
id?: string
12
+
/** The name of the track. */
13
+
name?: string
14
+
/** The name of the artist. */
15
+
artist?: string
16
+
/** The name of the album. */
17
+
album?: string
18
+
/** The duration of the track in milliseconds. */
19
+
duration?: number
20
+
/** A URL to a preview of the track. */
21
+
previewUrl?: string
22
+
[k: string]: unknown
23
+
}
24
+
25
+
export function isSpotifyTrackView(v: unknown): v is SpotifyTrackView {
26
+
return (
27
+
isObj(v) &&
28
+
hasProp(v, '$type') &&
29
+
v.$type === 'app.rocksky.spotify.defs#spotifyTrackView'
30
+
)
31
+
}
32
+
33
+
export function validateSpotifyTrackView(v: unknown): ValidationResult {
34
+
return lexicons.validate('app.rocksky.spotify.defs#spotifyTrackView', v)
35
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/spotify/getCurrentlyPlaying.ts
+43
apps/cli/src/lexicon/types/app/rocksky/spotify/getCurrentlyPlaying.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyPlayerDefs from '../player/defs'
11
+
12
+
export interface QueryParams {
13
+
/** Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user. */
14
+
actor?: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyPlayerDefs.CurrentlyPlayingViewDetailed
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/next.ts
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/next.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {}
12
+
13
+
export type InputSchema = undefined
14
+
export type HandlerInput = undefined
15
+
16
+
export interface HandlerError {
17
+
status: number
18
+
message?: string
19
+
}
20
+
21
+
export type HandlerOutput = HandlerError | void
22
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
23
+
auth: HA
24
+
params: QueryParams
25
+
input: HandlerInput
26
+
req: express.Request
27
+
res: express.Response
28
+
resetRouteRateLimits: () => Promise<void>
29
+
}
30
+
export type Handler<HA extends HandlerAuth = never> = (
31
+
ctx: HandlerReqCtx<HA>,
32
+
) => Promise<HandlerOutput> | HandlerOutput
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/pause.ts
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/pause.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {}
12
+
13
+
export type InputSchema = undefined
14
+
export type HandlerInput = undefined
15
+
16
+
export interface HandlerError {
17
+
status: number
18
+
message?: string
19
+
}
20
+
21
+
export type HandlerOutput = HandlerError | void
22
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
23
+
auth: HA
24
+
params: QueryParams
25
+
input: HandlerInput
26
+
req: express.Request
27
+
res: express.Response
28
+
resetRouteRateLimits: () => Promise<void>
29
+
}
30
+
export type Handler<HA extends HandlerAuth = never> = (
31
+
ctx: HandlerReqCtx<HA>,
32
+
) => Promise<HandlerOutput> | HandlerOutput
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/play.ts
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/play.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {}
12
+
13
+
export type InputSchema = undefined
14
+
export type HandlerInput = undefined
15
+
16
+
export interface HandlerError {
17
+
status: number
18
+
message?: string
19
+
}
20
+
21
+
export type HandlerOutput = HandlerError | void
22
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
23
+
auth: HA
24
+
params: QueryParams
25
+
input: HandlerInput
26
+
req: express.Request
27
+
res: express.Response
28
+
resetRouteRateLimits: () => Promise<void>
29
+
}
30
+
export type Handler<HA extends HandlerAuth = never> = (
31
+
ctx: HandlerReqCtx<HA>,
32
+
) => Promise<HandlerOutput> | HandlerOutput
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/previous.ts
+32
apps/cli/src/lexicon/types/app/rocksky/spotify/previous.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {}
12
+
13
+
export type InputSchema = undefined
14
+
export type HandlerInput = undefined
15
+
16
+
export interface HandlerError {
17
+
status: number
18
+
message?: string
19
+
}
20
+
21
+
export type HandlerOutput = HandlerError | void
22
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
23
+
auth: HA
24
+
params: QueryParams
25
+
input: HandlerInput
26
+
req: express.Request
27
+
res: express.Response
28
+
resetRouteRateLimits: () => Promise<void>
29
+
}
30
+
export type Handler<HA extends HandlerAuth = never> = (
31
+
ctx: HandlerReqCtx<HA>,
32
+
) => Promise<HandlerOutput> | HandlerOutput
+35
apps/cli/src/lexicon/types/app/rocksky/spotify/seek.ts
+35
apps/cli/src/lexicon/types/app/rocksky/spotify/seek.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
11
+
export interface QueryParams {
12
+
/** The position in seconds to seek to */
13
+
position: number
14
+
}
15
+
16
+
export type InputSchema = undefined
17
+
export type HandlerInput = undefined
18
+
19
+
export interface HandlerError {
20
+
status: number
21
+
message?: string
22
+
}
23
+
24
+
export type HandlerOutput = HandlerError | void
25
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
26
+
auth: HA
27
+
params: QueryParams
28
+
input: HandlerInput
29
+
req: express.Request
30
+
res: express.Response
31
+
resetRouteRateLimits: () => Promise<void>
32
+
}
33
+
export type Handler<HA extends HandlerAuth = never> = (
34
+
ctx: HandlerReqCtx<HA>,
35
+
) => Promise<HandlerOutput> | HandlerOutput
+33
apps/cli/src/lexicon/types/app/rocksky/stats/defs.ts
+33
apps/cli/src/lexicon/types/app/rocksky/stats/defs.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface StatsView {
10
+
/** The total number of scrobbles. */
11
+
scrobbles?: number
12
+
/** The total number of unique artists scrobbled. */
13
+
artists?: number
14
+
/** The total number of tracks marked as loved. */
15
+
lovedTracks?: number
16
+
/** The total number of unique albums scrobbled. */
17
+
albums?: number
18
+
/** The total number of unique tracks scrobbled. */
19
+
tracks?: number
20
+
[k: string]: unknown
21
+
}
22
+
23
+
export function isStatsView(v: unknown): v is StatsView {
24
+
return (
25
+
isObj(v) &&
26
+
hasProp(v, '$type') &&
27
+
v.$type === 'app.rocksky.stats.defs#statsView'
28
+
)
29
+
}
30
+
31
+
export function validateStatsView(v: unknown): ValidationResult {
32
+
return lexicons.validate('app.rocksky.stats.defs#statsView', v)
33
+
}
+43
apps/cli/src/lexicon/types/app/rocksky/stats/getStats.ts
+43
apps/cli/src/lexicon/types/app/rocksky/stats/getStats.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import express from 'express'
5
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
6
+
import { lexicons } from '../../../../lexicons'
7
+
import { isObj, hasProp } from '../../../../util'
8
+
import { CID } from 'multiformats/cid'
9
+
import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
10
+
import * as AppRockskyStatsDefs from './defs'
11
+
12
+
export interface QueryParams {
13
+
/** The DID or handle of the user to get stats for. */
14
+
did: string
15
+
}
16
+
17
+
export type InputSchema = undefined
18
+
export type OutputSchema = AppRockskyStatsDefs.StatsView
19
+
export type HandlerInput = undefined
20
+
21
+
export interface HandlerSuccess {
22
+
encoding: 'application/json'
23
+
body: OutputSchema
24
+
headers?: { [key: string]: string }
25
+
}
26
+
27
+
export interface HandlerError {
28
+
status: number
29
+
message?: string
30
+
}
31
+
32
+
export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
33
+
export type HandlerReqCtx<HA extends HandlerAuth = never> = {
34
+
auth: HA
35
+
params: QueryParams
36
+
input: HandlerInput
37
+
req: express.Request
38
+
res: express.Response
39
+
resetRouteRateLimits: () => Promise<void>
40
+
}
41
+
export type Handler<HA extends HandlerAuth = never> = (
42
+
ctx: HandlerReqCtx<HA>,
43
+
) => Promise<HandlerOutput> | HandlerOutput
+26
apps/cli/src/lexicon/types/com/atproto/repo/strongRef.ts
+26
apps/cli/src/lexicon/types/com/atproto/repo/strongRef.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { ValidationResult, BlobRef } from '@atproto/lexicon'
5
+
import { lexicons } from '../../../../lexicons'
6
+
import { isObj, hasProp } from '../../../../util'
7
+
import { CID } from 'multiformats/cid'
8
+
9
+
export interface Main {
10
+
uri: string
11
+
cid: string
12
+
[k: string]: unknown
13
+
}
14
+
15
+
export function isMain(v: unknown): v is Main {
16
+
return (
17
+
isObj(v) &&
18
+
hasProp(v, '$type') &&
19
+
(v.$type === 'com.atproto.repo.strongRef#main' ||
20
+
v.$type === 'com.atproto.repo.strongRef')
21
+
)
22
+
}
23
+
24
+
export function validateMain(v: unknown): ValidationResult {
25
+
return lexicons.validate('com.atproto.repo.strongRef#main', v)
26
+
}
+13
apps/cli/src/lexicon/util.ts
+13
apps/cli/src/lexicon/util.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
export function isObj(v: unknown): v is Record<string, unknown> {
5
+
return typeof v === 'object' && v !== null
6
+
}
7
+
8
+
export function hasProp<K extends PropertyKey>(
9
+
data: object,
10
+
prop: K,
11
+
): data is Record<K, unknown> {
12
+
return prop in data
13
+
}
+25
apps/cli/src/schema/album-tracks.ts
+25
apps/cli/src/schema/album-tracks.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import albums from "./albums";
4
+
import tracks from "./tracks";
5
+
6
+
const albumTracks = sqliteTable("album_tracks", {
7
+
id: text("id").primaryKey().notNull(),
8
+
albumId: text("album_id")
9
+
.notNull()
10
+
.references(() => albums.id),
11
+
trackId: text("track_id")
12
+
.notNull()
13
+
.references(() => tracks.id),
14
+
createdAt: integer("created_at")
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at")
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
});
21
+
22
+
export type SelectAlbumTrack = InferSelectModel<typeof albumTracks>;
23
+
export type InsertAlbumTrack = InferInsertModel<typeof albumTracks>;
24
+
25
+
export default albumTracks;
+29
apps/cli/src/schema/albums.ts
+29
apps/cli/src/schema/albums.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
4
+
const albums = sqliteTable("albums", {
5
+
id: text("id").primaryKey().notNull(),
6
+
title: text("title").notNull(),
7
+
artist: text("artist").notNull(),
8
+
releaseDate: text("release_date"),
9
+
year: integer("year"),
10
+
albumArt: text("album_art"),
11
+
uri: text("uri").unique(),
12
+
artistUri: text("artist_uri"),
13
+
appleMusicLink: text("apple_music_link").unique(),
14
+
spotifyLink: text("spotify_link").unique(),
15
+
tidalLink: text("tidal_link").unique(),
16
+
youtubeLink: text("youtube_link").unique(),
17
+
sha256: text("sha256").unique().notNull(),
18
+
createdAt: integer("created_at", { mode: "timestamp" })
19
+
.notNull()
20
+
.default(sql`CURRENT_TIMESTAMP`),
21
+
updatedAt: integer("updated_at", { mode: "timestamp" })
22
+
.notNull()
23
+
.default(sql`CURRENT_TIMESTAMP`),
24
+
});
25
+
26
+
export type SelectAlbum = InferSelectModel<typeof albums>;
27
+
export type InsertAlbum = InferInsertModel<typeof albums>;
28
+
29
+
export default albums;
+25
apps/cli/src/schema/artist-albums.ts
+25
apps/cli/src/schema/artist-albums.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import albums from "./albums";
4
+
import artists from "./artists";
5
+
6
+
const artistAlbums = sqliteTable("artist_albums", {
7
+
id: text("id").primaryKey().notNull(),
8
+
artistId: text("artist_id")
9
+
.notNull()
10
+
.references(() => artists.id),
11
+
albumId: text("album_id")
12
+
.notNull()
13
+
.references(() => albums.id),
14
+
createdAt: integer("created_at")
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at")
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
});
21
+
22
+
export type SelectArtistAlbum = InferSelectModel<typeof artistAlbums>;
23
+
export type InsertArtistAlbum = InferInsertModel<typeof artistAlbums>;
24
+
25
+
export default artistAlbums;
+25
apps/cli/src/schema/artist-tracks.ts
+25
apps/cli/src/schema/artist-tracks.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import artists from "./artists";
4
+
import tracks from "./tracks";
5
+
6
+
const artistTracks = sqliteTable("artist_tracks", {
7
+
id: text("id").primaryKey().notNull(),
8
+
artistId: text("artist_id")
9
+
.notNull()
10
+
.references(() => artists.id),
11
+
trackId: text("track_id")
12
+
.notNull()
13
+
.references(() => tracks.id),
14
+
createdAt: integer("created_at", { mode: "timestamp" })
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at", { mode: "timestamp" })
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
});
21
+
22
+
export type SelectArtistTrack = InferSelectModel<typeof artistTracks>;
23
+
export type InsertArtistTrack = InferInsertModel<typeof artistTracks>;
24
+
25
+
export default artistTracks;
+30
apps/cli/src/schema/artists.ts
+30
apps/cli/src/schema/artists.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
4
+
const artists = sqliteTable("artists", {
5
+
id: text("id").primaryKey().notNull(),
6
+
name: text("name").notNull(),
7
+
biography: text("biography"),
8
+
born: integer("born", { mode: "timestamp" }),
9
+
bornIn: text("born_in"),
10
+
died: integer("died", { mode: "timestamp" }),
11
+
picture: text("picture"),
12
+
sha256: text("sha256").unique().notNull(),
13
+
uri: text("uri").unique(),
14
+
appleMusicLink: text("apple_music_link"),
15
+
spotifyLink: text("spotify_link"),
16
+
tidalLink: text("tidal_link"),
17
+
youtubeLink: text("youtube_link"),
18
+
genres: text("genres"),
19
+
createdAt: integer("created_at", { mode: "timestamp" })
20
+
.notNull()
21
+
.default(sql`CURRENT_TIMESTAMP`),
22
+
updatedAt: integer("updated_at", { mode: "timestamp" })
23
+
.notNull()
24
+
.default(sql`CURRENT_TIMESTAMP`),
25
+
});
26
+
27
+
export type SelectArtist = InferSelectModel<typeof artists>;
28
+
export type InsertArtist = InferInsertModel<typeof artists>;
29
+
30
+
export default artists;
+13
apps/cli/src/schema/index.ts
+13
apps/cli/src/schema/index.ts
+23
apps/cli/src/schema/loved-tracks.ts
+23
apps/cli/src/schema/loved-tracks.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
3
+
import tracks from "./tracks";
4
+
import users from "./users";
5
+
6
+
const lovedTracks = sqliteTable("loved_tracks", {
7
+
id: text("id").primaryKey().notNull(),
8
+
userId: text("user_id")
9
+
.notNull()
10
+
.references(() => users.id),
11
+
trackId: text("track_id")
12
+
.notNull()
13
+
.references(() => tracks.id),
14
+
uri: text("uri").unique(),
15
+
createdAt: integer("created_at")
16
+
.notNull()
17
+
.default(sql`CURRENT_TIMESTAMP`),
18
+
});
19
+
20
+
export type SelectLovedTrack = InferSelectModel<typeof lovedTracks>;
21
+
export type InsertLovedTrack = InferInsertModel<typeof lovedTracks>;
22
+
23
+
export default lovedTracks;
+39
apps/cli/src/schema/tracks.ts
+39
apps/cli/src/schema/tracks.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
4
+
const tracks = sqliteTable("tracks", {
5
+
id: text("id").primaryKey().notNull(),
6
+
title: text("title").notNull(),
7
+
artist: text("artist").notNull(),
8
+
albumArtist: text("album_artist").notNull(),
9
+
albumArt: text("album_art"),
10
+
album: text("album").notNull(),
11
+
trackNumber: integer("track_number"),
12
+
duration: integer("duration").notNull(),
13
+
mbId: text("mb_id").unique(),
14
+
youtubeLink: text("youtube_link").unique(),
15
+
spotifyLink: text("spotify_link").unique(),
16
+
appleMusicLink: text("apple_music_link").unique(),
17
+
tidalLink: text("tidal_link").unique(),
18
+
sha256: text("sha256").unique().notNull(),
19
+
discNumber: integer("disc_number"),
20
+
lyrics: text("lyrics"),
21
+
composer: text("composer"),
22
+
genre: text("genre"),
23
+
label: text("label"),
24
+
copyrightMessage: text("copyright_message"),
25
+
uri: text("uri").unique(),
26
+
albumUri: text("album_uri"),
27
+
artistUri: text("artist_uri"),
28
+
createdAt: integer("created_at", { mode: "timestamp" })
29
+
.notNull()
30
+
.default(sql`CURRENT_TIMESTAMP`),
31
+
updatedAt: integer("updated_at", { mode: "timestamp" })
32
+
.notNull()
33
+
.default(sql`CURRENT_TIMESTAMP`),
34
+
});
35
+
36
+
export type SelectTrack = InferSelectModel<typeof tracks>;
37
+
export type InsertTrack = InferInsertModel<typeof tracks>;
38
+
39
+
export default tracks;
+27
apps/cli/src/schema/user-albums.ts
+27
apps/cli/src/schema/user-albums.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import albums from "./albums";
4
+
import users from "./users";
5
+
6
+
const userAlbums = sqliteTable("user_albums", {
7
+
id: text("id").primaryKey().notNull(),
8
+
userId: text("user_id")
9
+
.notNull()
10
+
.references(() => users.id),
11
+
albumId: text("album_id")
12
+
.notNull()
13
+
.references(() => albums.id),
14
+
createdAt: integer("created_at", { mode: "timestamp" })
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at", { mode: "timestamp" })
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
scrobbles: integer("scrobbles"),
21
+
uri: text("uri").unique().notNull(),
22
+
});
23
+
24
+
export type SelectUserAlbum = InferSelectModel<typeof userAlbums>;
25
+
export type InsertUserAlbum = InferInsertModel<typeof userAlbums>;
26
+
27
+
export default userAlbums;
+27
apps/cli/src/schema/user-artists.ts
+27
apps/cli/src/schema/user-artists.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import artists from "./artists";
4
+
import users from "./users";
5
+
6
+
const userArtists = sqliteTable("user_albums", {
7
+
id: text("id").primaryKey().notNull(),
8
+
userId: text("user_id")
9
+
.notNull()
10
+
.references(() => users.id),
11
+
albumId: text("artist_id")
12
+
.notNull()
13
+
.references(() => artists.id),
14
+
createdAt: integer("created_at", { mode: "timestamp" })
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at", { mode: "timestamp" })
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
scrobbles: integer("scrobbles"),
21
+
uri: text("uri").unique().notNull(),
22
+
});
23
+
24
+
export type SelectUserArtist = InferSelectModel<typeof userArtists>;
25
+
export type InsertUserArtist = InferInsertModel<typeof userArtists>;
26
+
27
+
export default userArtists;
+27
apps/cli/src/schema/user-tracks.ts
+27
apps/cli/src/schema/user-tracks.ts
···
1
+
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
import tracks from "./tracks";
4
+
import users from "./users";
5
+
6
+
const userTracks = sqliteTable("user_tracks", {
7
+
id: text("id").primaryKey().notNull(),
8
+
userId: text("user_id")
9
+
.notNull()
10
+
.references(() => users.id),
11
+
albumId: text("track_id")
12
+
.notNull()
13
+
.references(() => tracks.id),
14
+
createdAt: integer("created_at", { mode: "timestamp" })
15
+
.notNull()
16
+
.default(sql`CURRENT_TIMESTAMP`),
17
+
updatedAt: integer("updated_at", { mode: "timestamp" })
18
+
.notNull()
19
+
.default(sql`CURRENT_TIMESTAMP`),
20
+
scrobbles: integer("scrobbles"),
21
+
uri: text("uri").unique().notNull(),
22
+
});
23
+
24
+
export type SelectUser = InferSelectModel<typeof userTracks>;
25
+
export type InsertUserTrack = InferInsertModel<typeof userTracks>;
26
+
27
+
export default userTracks;
+21
apps/cli/src/schema/users.ts
+21
apps/cli/src/schema/users.ts
···
1
+
import { type InferSelectModel, sql } from "drizzle-orm";
2
+
import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
3
+
4
+
const users = sqliteTable("users", {
5
+
id: text("id").primaryKey().notNull(),
6
+
did: text("did").unique().notNull(),
7
+
displayName: text("display_name"),
8
+
handle: text("handle").unique().notNull(),
9
+
avatar: text("avatar").notNull(),
10
+
createdAt: integer("created_at", { mode: "timestamp" })
11
+
.notNull()
12
+
.default(sql`CURRENT_TIMESTAMP`),
13
+
updatedAt: integer("updated_at", { mode: "timestamp" })
14
+
.notNull()
15
+
.default(sql`CURRENT_TIMESTAMP`),
16
+
});
17
+
18
+
export type SelectUser = InferSelectModel<typeof users>;
19
+
export type InsertUser = InferSelectModel<typeof users>;
20
+
21
+
export default users;
apps/cli/src/sync.ts
apps/cli/src/sync.ts
This is a binary file and will not be displayed.
+63
-3
bun.lock
+63
-3
bun.lock
···
107
107
"rocksky": "./dist/index.js",
108
108
},
109
109
"dependencies": {
110
+
"@atcute/jetstream": "^1.1.2",
111
+
"@atproto/api": "^0.13.31",
112
+
"@atproto/common": "^0.4.6",
113
+
"@atproto/identity": "^0.4.5",
114
+
"@atproto/jwk-jose": "0.1.5",
115
+
"@atproto/lex-cli": "^0.5.6",
116
+
"@atproto/lexicon": "^0.4.5",
117
+
"@atproto/sync": "^0.1.11",
118
+
"@atproto/syntax": "^0.3.1",
110
119
"@modelcontextprotocol/sdk": "^1.10.2",
120
+
"@paralleldrive/cuid2": "^3.0.6",
121
+
"@types/better-sqlite3": "^7.6.13",
111
122
"axios": "^1.8.4",
123
+
"better-sqlite3": "^12.4.1",
112
124
"chalk": "^5.4.1",
113
125
"commander": "^13.1.0",
114
126
"cors": "^2.8.5",
115
127
"dayjs": "^1.11.13",
128
+
"drizzle-kit": "^0.31.1",
129
+
"drizzle-orm": "^0.45.1",
130
+
"effect": "^3.19.14",
131
+
"env-paths": "^3.0.0",
116
132
"express": "^5.1.0",
117
133
"md5": "^2.3.0",
118
134
"open": "^10.1.0",
···
342
358
343
359
"@asteasolutions/zod-to-openapi": ["@asteasolutions/zod-to-openapi@7.3.4", "", { "dependencies": { "openapi3-ts": "^4.1.2" }, "peerDependencies": { "zod": "^3.20.2" } }, "sha512-/2rThQ5zPi9OzVwes6U7lK1+Yvug0iXu25olp7S0XsYmOqnyMfxH7gdSQjn/+DSOHRg7wnotwGJSyL+fBKdnEA=="],
344
360
361
+
"@atcute/jetstream": ["@atcute/jetstream@1.1.2", "", { "dependencies": { "@atcute/lexicons": "^1.2.2", "@badrap/valita": "^0.4.6", "@mary-ext/event-iterator": "^1.0.0", "@mary-ext/simple-event-emitter": "^1.0.0", "partysocket": "^1.1.5", "type-fest": "^4.41.0", "yocto-queue": "^1.2.1" } }, "sha512-u6p/h2xppp7LE6W/9xErAJ6frfN60s8adZuCKtfAaaBBiiYbb1CfpzN8Uc+2qtJZNorqGvuuDb5572Jmh7yHBQ=="],
362
+
363
+
"@atcute/lexicons": ["@atcute/lexicons@1.2.6", "", { "dependencies": { "@atcute/uint8array": "^1.0.6", "@atcute/util-text": "^0.0.1", "@standard-schema/spec": "^1.1.0", "esm-env": "^1.2.2" } }, "sha512-s76UQd8D+XmHIzrjD9CJ9SOOeeLPHc+sMmcj7UFakAW/dDFXc579fcRdRfuUKvXBL5v1Gs2VgDdlh/IvvQZAwA=="],
364
+
365
+
"@atcute/uint8array": ["@atcute/uint8array@1.0.6", "", {}, "sha512-ucfRBQc7BFT8n9eCyGOzDHEMKF/nZwhS2pPao4Xtab1ML3HdFYcX2DM1tadCzas85QTGxHe5urnUAAcNKGRi9A=="],
366
+
367
+
"@atcute/util-text": ["@atcute/util-text@0.0.1", "", { "dependencies": { "unicode-segmenter": "^0.14.4" } }, "sha512-t1KZqvn0AYy+h2KcJyHnKF9aEqfRfMUmyY8j1ELtAEIgqN9CxINAjxnoRCJIFUlvWzb+oY3uElQL/Vyk3yss0g=="],
368
+
345
369
"@atproto-labs/did-resolver": ["@atproto-labs/did-resolver@0.1.11", "", { "dependencies": { "@atproto-labs/fetch": "0.2.2", "@atproto-labs/pipe": "0.1.0", "@atproto-labs/simple-store": "0.1.2", "@atproto-labs/simple-store-memory": "0.1.2", "@atproto/did": "0.1.5", "zod": "^3.23.8" } }, "sha512-qXNzIX2GPQnxT1gl35nv/8ErDdc4Fj/+RlJE7oyE7JGkFAPUyuY03TvKJ79SmWFsWE8wyTXEpLuphr9Da1Vhkw=="],
346
370
347
371
"@atproto-labs/fetch": ["@atproto-labs/fetch@0.2.2", "", { "dependencies": { "@atproto-labs/pipe": "0.1.0" } }, "sha512-QyafkedbFeVaN20DYUpnY2hcArYxjdThPXbYMqOSoZhcvkrUqaw4xDND4wZB5TBD9cq2yqe9V6mcw9P4XQKQuQ=="],
···
456
480
457
481
"@babel/types": ["@babel/types@7.28.4", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q=="],
458
482
483
+
"@badrap/valita": ["@badrap/valita@0.4.6", "", {}, "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg=="],
484
+
459
485
"@biomejs/biome": ["@biomejs/biome@2.2.5", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.2.5", "@biomejs/cli-darwin-x64": "2.2.5", "@biomejs/cli-linux-arm64": "2.2.5", "@biomejs/cli-linux-arm64-musl": "2.2.5", "@biomejs/cli-linux-x64": "2.2.5", "@biomejs/cli-linux-x64-musl": "2.2.5", "@biomejs/cli-win32-arm64": "2.2.5", "@biomejs/cli-win32-x64": "2.2.5" }, "bin": { "biome": "bin/biome" } }, "sha512-zcIi+163Rc3HtyHbEO7CjeHq8DjQRs40HsGbW6vx2WI0tg8mYQOPouhvHSyEnCBAorfYNnKdR64/IxO7xQ5faw=="],
460
486
461
487
"@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.2.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-MYT+nZ38wEIWVcL5xLyOhYQQ7nlWD0b/4mgATW2c8dvq7R4OQjt/XGXFkXrmtWmQofaIM14L7V8qIz/M+bx5QQ=="],
···
726
752
727
753
"@mapbox/whoots-js": ["@mapbox/whoots-js@3.1.0", "", {}, "sha512-Es6WcD0nO5l+2BOQS4uLfNPYQaNDfbot3X1XUoloz+x0mPDS3eeORZJl06HXjwBG1fOGwCRnzK88LMdxKRrd6Q=="],
728
754
755
+
"@mary-ext/event-iterator": ["@mary-ext/event-iterator@1.0.0", "", { "dependencies": { "yocto-queue": "^1.2.1" } }, "sha512-l6gCPsWJ8aRCe/s7/oCmero70kDHgIK5m4uJvYgwEYTqVxoBOIXbKr5tnkLqUHEg6mNduB4IWvms3h70Hp9ADQ=="],
756
+
757
+
"@mary-ext/simple-event-emitter": ["@mary-ext/simple-event-emitter@1.0.0", "", {}, "sha512-meA/zJZKIN1RVBNEYIbjufkUrW7/tRjHH60FjolpG1ixJKo76TB208qefQLNdOVDA7uIG0CGEDuhmMirtHKLAg=="],
758
+
729
759
"@math.gl/web-mercator": ["@math.gl/web-mercator@3.6.3", "", { "dependencies": { "@babel/runtime": "^7.12.0", "gl-matrix": "^3.4.0" } }, "sha512-UVrkSOs02YLehKaehrxhAejYMurehIHPfFQvPFZmdJHglHOU4V2cCUApTVEwOksvCp161ypEqVp+9H6mGhTTcw=="],
730
760
731
761
"@mdx-js/react": ["@mdx-js/react@3.1.1", "", { "dependencies": { "@types/mdx": "^2.0.0" }, "peerDependencies": { "@types/react": ">=16", "react": ">=16" } }, "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw=="],
···
734
764
735
765
"@noble/curves": ["@noble/curves@1.9.7", "", { "dependencies": { "@noble/hashes": "1.8.0" } }, "sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw=="],
736
766
737
-
"@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
767
+
"@noble/hashes": ["@noble/hashes@2.0.1", "", {}, "sha512-XlOlEbQcE9fmuXxrVTXCTlG2nlRXa9Rj3rr5Ue/+tX+nmkgbX720YHh0VR3hBF9xDvwnb8D2shVGOwNx+ulArw=="],
738
768
739
769
"@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
740
770
···
896
926
897
927
"@opentelemetry/sql-common": ["@opentelemetry/sql-common@0.41.2", "", { "dependencies": { "@opentelemetry/core": "^2.0.0" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0" } }, "sha512-4mhWm3Z8z+i508zQJ7r6Xi7y4mmoJpdvH0fZPFRkWrdp5fq7hhZ2HhYokEOLkfqSMgPR4Z9EyB3DBkbKGOqZiQ=="],
898
928
929
+
"@paralleldrive/cuid2": ["@paralleldrive/cuid2@3.0.6", "", { "dependencies": { "@noble/hashes": "^2.0.1", "bignumber.js": "^9.3.1", "error-causes": "^3.0.2" }, "bin": { "cuid2": "bin/cuid2.js" } }, "sha512-ujtxTTvr4fwPrzuQT7o6VLKs5BzdWetR9+/zRQ0SyK9hVIwZQllEccxgcHYXN6I3Z429y1yg3F6+uiVxMDPrLQ=="],
930
+
899
931
"@pkgjs/parseargs": ["@pkgjs/parseargs@0.11.0", "", {}, "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg=="],
900
932
901
933
"@pkl-community/pkl": ["@pkl-community/pkl@0.28.2", "", { "optionalDependencies": { "@pkl-community/pkl-darwin-arm64": "0.28.2", "@pkl-community/pkl-darwin-x64": "0.28.2", "@pkl-community/pkl-linux-arm64": "0.28.2", "@pkl-community/pkl-linux-x64": "0.28.2" }, "bin": { "pkl": "lib/main.js" } }, "sha512-seSZrwGvDEd1BeT9+dRRnqvyNit8vpFL2I+YBEJ+t3pBYpnpHaVHwQNPlMLvDQ0KZUCQkiWGZnbCMF9WtaxHNA=="],
···
1245
1277
"@types/babel__template": ["@types/babel__template@7.4.4", "", { "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A=="],
1246
1278
1247
1279
"@types/babel__traverse": ["@types/babel__traverse@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.2" } }, "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q=="],
1280
+
1281
+
"@types/better-sqlite3": ["@types/better-sqlite3@7.6.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA=="],
1248
1282
1249
1283
"@types/body-parser": ["@types/body-parser@1.19.6", "", { "dependencies": { "@types/connect": "*", "@types/node": "*" } }, "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g=="],
1250
1284
···
1742
1776
1743
1777
"enhanced-resolve": ["enhanced-resolve@5.18.3", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" } }, "sha512-d4lC8xfavMeBjzGr2vECC3fsGXziXZQyJxD868h2M/mBI3PwAuODxAkLkq5HYuvrPYcUtiLzsTo8U3PgX3Ocww=="],
1744
1778
1779
+
"env-paths": ["env-paths@3.0.0", "", {}, "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A=="],
1780
+
1745
1781
"envalid": ["envalid@8.1.0", "", { "dependencies": { "tslib": "2.8.1" } }, "sha512-OT6+qVhKVyCidaGoXflb2iK1tC8pd0OV2Q+v9n33wNhUJ+lus+rJobUj4vJaQBPxPZ0vYrPGuxdrenyCAIJcow=="],
1782
+
1783
+
"error-causes": ["error-causes@3.0.2", "", {}, "sha512-i0B8zq1dHL6mM85FGoxaJnVtx6LD5nL2v0hlpGdntg5FOSyzQ46c9lmz5qx0xRS2+PWHGOHcYxGIBC5Le2dRMw=="],
1746
1784
1747
1785
"error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="],
1748
1786
···
1779
1817
"eslint-scope": ["eslint-scope@8.4.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg=="],
1780
1818
1781
1819
"eslint-visitor-keys": ["eslint-visitor-keys@4.2.1", "", {}, "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ=="],
1820
+
1821
+
"esm-env": ["esm-env@1.2.2", "", {}, "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA=="],
1782
1822
1783
1823
"espree": ["espree@10.4.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ=="],
1784
1824
···
1796
1836
1797
1837
"etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
1798
1838
1839
+
"event-target-polyfill": ["event-target-polyfill@0.0.4", "", {}, "sha512-Gs6RLjzlLRdT8X9ZipJdIZI/Y6/HhRLyq9RdDlCsnpxr/+Nn6bU2EFGuC94GjxqhM+Nmij2Vcq98yoHrU8uNFQ=="],
1840
+
1799
1841
"event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
1800
1842
1801
1843
"eventemitter3": ["eventemitter3@4.0.7", "", {}, "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="],
···
2314
2356
2315
2357
"parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
2316
2358
2359
+
"partysocket": ["partysocket@1.1.10", "", { "dependencies": { "event-target-polyfill": "^0.0.4" } }, "sha512-ACfn0P6lQuj8/AqB4L5ZDFcIEbpnIteNNObrlxqV1Ge80GTGhjuJ2sNKwNQlFzhGi4kI7fP/C1Eqh8TR78HjDQ=="],
2360
+
2317
2361
"path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
2318
2362
2319
2363
"path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
···
2768
2812
2769
2813
"type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
2770
2814
2771
-
"type-fest": ["type-fest@2.19.0", "", {}, "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="],
2815
+
"type-fest": ["type-fest@4.41.0", "", {}, "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA=="],
2772
2816
2773
2817
"type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],
2774
2818
···
2789
2833
"undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
2790
2834
2791
2835
"unenv": ["unenv@2.0.0-rc.14", "", { "dependencies": { "defu": "^6.1.4", "exsolve": "^1.0.1", "ohash": "^2.0.10", "pathe": "^2.0.3", "ufo": "^1.5.4" } }, "sha512-od496pShMen7nOy5VmVJCnq8rptd45vh6Nx/r2iPbrba6pa6p+tS2ywuIHRZ/OBvSbQZB0kWvpO9XBNVFXHD3Q=="],
2836
+
2837
+
"unicode-segmenter": ["unicode-segmenter@0.14.5", "", {}, "sha512-jHGmj2LUuqDcX3hqY12Ql+uhUTn8huuxNZGq7GvtF6bSybzH3aFgedYu/KTzQStEgt1Ra2F3HxadNXsNjb3m3g=="],
2792
2838
2793
2839
"universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
2794
2840
···
2884
2930
2885
2931
"yesno": ["yesno@0.4.0", "", {}, "sha512-tdBxmHvbXPBKYIg81bMCB7bVeDmHkRzk5rVJyYYXurwKkHq/MCd8rz4HSJUP7hW0H2NlXiq8IFiWvYKEHhlotA=="],
2886
2932
2887
-
"yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
2933
+
"yocto-queue": ["yocto-queue@1.2.2", "", {}, "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ=="],
2888
2934
2889
2935
"youch": ["youch@3.2.3", "", { "dependencies": { "cookie": "^0.5.0", "mustache": "^4.2.0", "stacktracey": "^2.1.8" } }, "sha512-ZBcWz/uzZaQVdCvfV4uk616Bbpf2ee+F/AvuKDR5EwX/Y4v06xWdtMluqTD7+KlZdM93lLm9gMZYo0sKBS0pgw=="],
2890
2936
···
2896
2942
2897
2943
"zx": ["zx@8.8.4", "", { "bin": { "zx": "build/cli.js" } }, "sha512-44GcD+ZlM/v1OQtbwnSxLPcoE1ZEUICmR+RSbJZLAqfIixNLuMjLyh0DcS75OyfJ/sWYAwCWDmDvJ4hdnANAPQ=="],
2898
2944
2945
+
"@atcute/lexicons/@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
2946
+
2899
2947
"@atproto-labs/fetch-node/ipaddr.js": ["ipaddr.js@2.2.0", "", {}, "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA=="],
2900
2948
2901
2949
"@atproto-labs/fetch-node/undici": ["undici@6.22.0", "", {}, "sha512-hU/10obOIu62MGYjdskASR3CUAiYaFTtC9Pa6vHyf//mAipSvSQg6od2CnJswq7fvzNS3zJhxoRkgNVaHurWKw=="],
2902
2950
2903
2951
"@atproto-labs/identity-resolver/@atproto/syntax": ["@atproto/syntax@0.4.0", "", {}, "sha512-b9y5ceHS8YKOfP3mdKmwAx5yVj9294UN7FG2XzP6V5aKUdFazEYRnR9m5n5ZQFKa3GNvz7de9guZCJ/sUTcOAA=="],
2952
+
2953
+
"@atproto/crypto/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
2904
2954
2905
2955
"@atproto/jwk-jose/jose": ["jose@5.10.0", "", {}, "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg=="],
2906
2956
···
2961
3011
"@jridgewell/gen-mapping/@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
2962
3012
2963
3013
"@jridgewell/remapping/@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
3014
+
3015
+
"@noble/curves/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
2964
3016
2965
3017
"@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/core": ["@opentelemetry/core@2.0.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-SLX36allrcnVaPYG3R78F/UZZsBsvbc7lMCLx37LyH5MJ1KAAZ2E3mW9OAD3zGz0G8q/BtoS5VUrjzDydhD6LQ=="],
2966
3018
···
3046
3098
3047
3099
"@poppinss/dumper/supports-color": ["supports-color@10.2.2", "", {}, "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g=="],
3048
3100
3101
+
"@rocksky/cli/drizzle-orm": ["drizzle-orm@0.45.1", "", { "peerDependencies": { "@aws-sdk/client-rds-data": ">=3", "@cloudflare/workers-types": ">=4", "@electric-sql/pglite": ">=0.2.0", "@libsql/client": ">=0.10.0", "@libsql/client-wasm": ">=0.10.0", "@neondatabase/serverless": ">=0.10.0", "@op-engineering/op-sqlite": ">=2", "@opentelemetry/api": "^1.4.1", "@planetscale/database": ">=1.13", "@prisma/client": "*", "@tidbcloud/serverless": "*", "@types/better-sqlite3": "*", "@types/pg": "*", "@types/sql.js": "*", "@upstash/redis": ">=1.34.7", "@vercel/postgres": ">=0.8.0", "@xata.io/client": "*", "better-sqlite3": ">=7", "bun-types": "*", "expo-sqlite": ">=14.0.0", "gel": ">=2", "knex": "*", "kysely": "*", "mysql2": ">=2", "pg": ">=8", "postgres": ">=3", "sql.js": ">=1", "sqlite3": ">=5" }, "optionalPeers": ["@aws-sdk/client-rds-data", "@cloudflare/workers-types", "@electric-sql/pglite", "@libsql/client", "@libsql/client-wasm", "@neondatabase/serverless", "@op-engineering/op-sqlite", "@opentelemetry/api", "@planetscale/database", "@prisma/client", "@tidbcloud/serverless", "@types/better-sqlite3", "@types/pg", "@types/sql.js", "@upstash/redis", "@vercel/postgres", "@xata.io/client", "better-sqlite3", "bun-types", "expo-sqlite", "gel", "knex", "kysely", "mysql2", "pg", "postgres", "sql.js", "sqlite3"] }, "sha512-Te0FOdKIistGNPMq2jscdqngBRfBpC8uMFVwqjf6gtTVJHIQ/dosgV/CLBU2N4ZJBsXL5savCba9b0YJskKdcA=="],
3102
+
3103
+
"@rocksky/cli/effect": ["effect@3.19.14", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "fast-check": "^3.23.1" } }, "sha512-3vwdq0zlvQOxXzXNKRIPKTqZNMyGCdaFUBfMPqpsyzZDre67kgC1EEHDV4EoQTovJ4w5fmJW756f86kkuz7WFA=="],
3104
+
3049
3105
"@rocksky/doc/vitest": ["vitest@2.1.9", "", { "dependencies": { "@vitest/expect": "2.1.9", "@vitest/mocker": "2.1.9", "@vitest/pretty-format": "^2.1.9", "@vitest/runner": "2.1.9", "@vitest/snapshot": "2.1.9", "@vitest/spy": "2.1.9", "@vitest/utils": "2.1.9", "chai": "^5.1.2", "debug": "^4.3.7", "expect-type": "^1.1.0", "magic-string": "^0.30.12", "pathe": "^1.1.2", "std-env": "^3.8.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.1", "tinypool": "^1.0.1", "tinyrainbow": "^1.2.0", "vite": "^5.0.0", "vite-node": "2.1.9", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/node": "^18.0.0 || >=20.0.0", "@vitest/browser": "2.1.9", "@vitest/ui": "2.1.9", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q=="],
3050
3106
3051
3107
"@rocksky/spotify-proxy/@cloudflare/vitest-pool-workers": ["@cloudflare/vitest-pool-workers@0.8.71", "", { "dependencies": { "birpc": "0.2.14", "cjs-module-lexer": "^1.2.3", "devalue": "^5.3.2", "miniflare": "4.20250906.0", "semver": "^7.7.1", "wrangler": "4.35.0", "zod": "^3.22.3" }, "peerDependencies": { "@vitest/runner": "2.0.x - 3.2.x", "@vitest/snapshot": "2.0.x - 3.2.x", "vitest": "2.0.x - 3.2.x" } }, "sha512-keu2HCLQfRNwbmLBCDXJgCFpANTaYnQpE01fBOo4CNwiWHUT7SZGN7w64RKiSWRHyYppStXBuE5Ng7F42+flpg=="],
···
3067
3123
"@rocksky/web-mobile/vitest": ["vitest@3.0.9", "", { "dependencies": { "@vitest/expect": "3.0.9", "@vitest/mocker": "3.0.9", "@vitest/pretty-format": "^3.0.9", "@vitest/runner": "3.0.9", "@vitest/snapshot": "3.0.9", "@vitest/spy": "3.0.9", "@vitest/utils": "3.0.9", "chai": "^5.2.0", "debug": "^4.4.0", "expect-type": "^1.1.0", "magic-string": "^0.30.17", "pathe": "^2.0.3", "std-env": "^3.8.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinypool": "^1.0.2", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0", "vite-node": "3.0.9", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.0.9", "@vitest/ui": "3.0.9", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-BbcFDqNyBlfSpATmTtXOAOj71RNKDDvjBM/uPfnxxVGrG+FSH2RQIwgeEngTaTkuU/h0ScFvf+tRcKfYXzBybQ=="],
3068
3124
3069
3125
"@storybook/addon-actions/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
3126
+
3127
+
"@storybook/csf/type-fest": ["type-fest@2.19.0", "", {}, "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="],
3070
3128
3071
3129
"@storybook/csf-plugin/unplugin": ["unplugin@1.16.1", "", { "dependencies": { "acorn": "^8.14.0", "webpack-virtual-modules": "^0.6.2" } }, "sha512-4/u/j4FrCKdi17jaxuJA0jClGxB1AvU2hw/IuayPc4ay1XGaJs/rbb4v5WKwAjNifjmXK9PIFyuPiaK8azyR9w=="],
3072
3130
···
3193
3251
"mlly/acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
3194
3252
3195
3253
"mlly/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
3254
+
3255
+
"p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
3196
3256
3197
3257
"pkg-types/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
3198
3258