zbrox.com
+2
crates/jacquard-api/Cargo.toml
+2
crates/jacquard-api/Cargo.toml
···
37
app_blebbit = []
38
app_bsky = []
39
app_ocho = []
40
+
app_rocksky = []
41
beauty_cybernetic = []
42
blog_pckt = []
43
blue__2048 = []
···
63
moe_karashiiro = []
64
my_skylights = []
65
net_aftertheinter = []
66
+
net_altq = []
67
net_anisota = ["app_bsky"]
68
net_bnewbold = []
69
net_mmatt = []
+78
crates/jacquard-api/lexicons/app_rocksky_actor_defs.json
+78
crates/jacquard-api/lexicons/app_rocksky_actor_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.defs",
4
+
"defs": {
5
+
"profileViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"avatar": {
9
+
"type": "string",
10
+
"description": "The URL of the actor's avatar image.",
11
+
"format": "uri"
12
+
},
13
+
"createdAt": {
14
+
"type": "string",
15
+
"description": "The date and time when the actor was created.",
16
+
"format": "datetime"
17
+
},
18
+
"did": {
19
+
"type": "string",
20
+
"description": "The DID of the actor."
21
+
},
22
+
"displayName": {
23
+
"type": "string",
24
+
"description": "The display name of the actor."
25
+
},
26
+
"handle": {
27
+
"type": "string",
28
+
"description": "The handle of the actor."
29
+
},
30
+
"id": {
31
+
"type": "string",
32
+
"description": "The unique identifier of the actor."
33
+
},
34
+
"updatedAt": {
35
+
"type": "string",
36
+
"description": "The date and time when the actor was last updated.",
37
+
"format": "datetime"
38
+
}
39
+
}
40
+
},
41
+
"profileViewDetailed": {
42
+
"type": "object",
43
+
"properties": {
44
+
"avatar": {
45
+
"type": "string",
46
+
"description": "The URL of the actor's avatar image.",
47
+
"format": "uri"
48
+
},
49
+
"createdAt": {
50
+
"type": "string",
51
+
"description": "The date and time when the actor was created.",
52
+
"format": "datetime"
53
+
},
54
+
"did": {
55
+
"type": "string",
56
+
"description": "The DID of the actor."
57
+
},
58
+
"displayName": {
59
+
"type": "string",
60
+
"description": "The display name of the actor."
61
+
},
62
+
"handle": {
63
+
"type": "string",
64
+
"description": "The handle of the actor."
65
+
},
66
+
"id": {
67
+
"type": "string",
68
+
"description": "The unique identifier of the actor."
69
+
},
70
+
"updatedAt": {
71
+
"type": "string",
72
+
"description": "The date and time when the actor was last updated.",
73
+
"format": "datetime"
74
+
}
75
+
}
76
+
}
77
+
}
78
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorAlbums.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorAlbums.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorAlbums",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get albums for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"albums": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.album.defs#albumViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorArtists.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorArtists.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorArtists",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get artists for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"artists": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.artist.defs#artistViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorLovedSongs.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorLovedSongs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorLovedSongs",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get loved songs for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"tracks": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.song.defs#songViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorPlaylists.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorPlaylists.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorPlaylists",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get playlists for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"playlists": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.playlist.defs#playlistViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorScrobbles.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorScrobbles.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorScrobbles",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get scrobbles for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"scrobbles": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorSongs.json
+48
crates/jacquard-api/lexicons/app_rocksky_actor_getActorSongs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getActorSongs",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get songs for an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of albums to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"songs": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.song.defs#songViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+27
crates/jacquard-api/lexicons/app_rocksky_actor_getProfile.json
+27
crates/jacquard-api/lexicons/app_rocksky_actor_getProfile.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.actor.getProfile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get the profile of an actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"did": {
12
+
"type": "string",
13
+
"description": "The DID or handle of the actor",
14
+
"format": "at-identifier"
15
+
}
16
+
}
17
+
},
18
+
"output": {
19
+
"encoding": "application/json",
20
+
"schema": {
21
+
"type": "ref",
22
+
"ref": "app.rocksky.actor.defs#profileViewDetailed"
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+94
crates/jacquard-api/lexicons/app_rocksky_album.json
+94
crates/jacquard-api/lexicons/app_rocksky_album.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.album",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of an album.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"title",
13
+
"artist",
14
+
"createdAt"
15
+
],
16
+
"properties": {
17
+
"albumArt": {
18
+
"type": "blob",
19
+
"description": "The album art of the album.",
20
+
"accept": [
21
+
"image/png",
22
+
"image/jpeg"
23
+
],
24
+
"maxSize": 2000000
25
+
},
26
+
"appleMusicLink": {
27
+
"type": "string",
28
+
"description": "The Apple Music link of the album.",
29
+
"format": "uri"
30
+
},
31
+
"artist": {
32
+
"type": "string",
33
+
"description": "The artist of the album.",
34
+
"minLength": 1,
35
+
"maxLength": 256
36
+
},
37
+
"createdAt": {
38
+
"type": "string",
39
+
"description": "The date and time when the album was created.",
40
+
"format": "datetime"
41
+
},
42
+
"duration": {
43
+
"type": "integer",
44
+
"description": "The duration of the album in seconds."
45
+
},
46
+
"genre": {
47
+
"type": "string",
48
+
"description": "The genre of the album.",
49
+
"maxLength": 256
50
+
},
51
+
"releaseDate": {
52
+
"type": "string",
53
+
"description": "The release date of the album.",
54
+
"format": "datetime"
55
+
},
56
+
"spotifyLink": {
57
+
"type": "string",
58
+
"description": "The Spotify link of the album.",
59
+
"format": "uri"
60
+
},
61
+
"tags": {
62
+
"type": "array",
63
+
"description": "The tags of the album.",
64
+
"items": {
65
+
"type": "string",
66
+
"minLength": 1,
67
+
"maxLength": 256
68
+
}
69
+
},
70
+
"tidalLink": {
71
+
"type": "string",
72
+
"description": "The tidal link of the album.",
73
+
"format": "uri"
74
+
},
75
+
"title": {
76
+
"type": "string",
77
+
"description": "The title of the album.",
78
+
"minLength": 1,
79
+
"maxLength": 512
80
+
},
81
+
"year": {
82
+
"type": "integer",
83
+
"description": "The year the album was released."
84
+
},
85
+
"youtubeLink": {
86
+
"type": "string",
87
+
"description": "The YouTube link of the album.",
88
+
"format": "uri"
89
+
}
90
+
}
91
+
}
92
+
}
93
+
}
94
+
}
+121
crates/jacquard-api/lexicons/app_rocksky_album_defs.json
+121
crates/jacquard-api/lexicons/app_rocksky_album_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.album.defs",
4
+
"defs": {
5
+
"albumViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"albumArt": {
9
+
"type": "string",
10
+
"description": "The URL of the album art image.",
11
+
"format": "uri"
12
+
},
13
+
"artist": {
14
+
"type": "string",
15
+
"description": "The artist of the album."
16
+
},
17
+
"artistUri": {
18
+
"type": "string",
19
+
"description": "The URI of the album's artist.",
20
+
"format": "at-uri"
21
+
},
22
+
"id": {
23
+
"type": "string",
24
+
"description": "The unique identifier of the album."
25
+
},
26
+
"playCount": {
27
+
"type": "integer",
28
+
"description": "The number of times the album has been played.",
29
+
"minimum": 0
30
+
},
31
+
"releaseDate": {
32
+
"type": "string",
33
+
"description": "The release date of the album."
34
+
},
35
+
"sha256": {
36
+
"type": "string",
37
+
"description": "The SHA256 hash of the album."
38
+
},
39
+
"title": {
40
+
"type": "string",
41
+
"description": "The title of the album."
42
+
},
43
+
"uniqueListeners": {
44
+
"type": "integer",
45
+
"description": "The number of unique listeners who have played the album.",
46
+
"minimum": 0
47
+
},
48
+
"uri": {
49
+
"type": "string",
50
+
"description": "The URI of the album.",
51
+
"format": "at-uri"
52
+
},
53
+
"year": {
54
+
"type": "integer",
55
+
"description": "The year the album was released."
56
+
}
57
+
}
58
+
},
59
+
"albumViewDetailed": {
60
+
"type": "object",
61
+
"properties": {
62
+
"albumArt": {
63
+
"type": "string",
64
+
"description": "The URL of the album art image.",
65
+
"format": "uri"
66
+
},
67
+
"artist": {
68
+
"type": "string",
69
+
"description": "The artist of the album."
70
+
},
71
+
"artistUri": {
72
+
"type": "string",
73
+
"description": "The URI of the album's artist.",
74
+
"format": "at-uri"
75
+
},
76
+
"id": {
77
+
"type": "string",
78
+
"description": "The unique identifier of the album."
79
+
},
80
+
"playCount": {
81
+
"type": "integer",
82
+
"description": "The number of times the album has been played.",
83
+
"minimum": 0
84
+
},
85
+
"releaseDate": {
86
+
"type": "string",
87
+
"description": "The release date of the album."
88
+
},
89
+
"sha256": {
90
+
"type": "string",
91
+
"description": "The SHA256 hash of the album."
92
+
},
93
+
"title": {
94
+
"type": "string",
95
+
"description": "The title of the album."
96
+
},
97
+
"tracks": {
98
+
"type": "array",
99
+
"items": {
100
+
"type": "ref",
101
+
"ref": "app.rocksky.song.defs.songViewBasic"
102
+
}
103
+
},
104
+
"uniqueListeners": {
105
+
"type": "integer",
106
+
"description": "The number of unique listeners who have played the album.",
107
+
"minimum": 0
108
+
},
109
+
"uri": {
110
+
"type": "string",
111
+
"description": "The URI of the album.",
112
+
"format": "at-uri"
113
+
},
114
+
"year": {
115
+
"type": "integer",
116
+
"description": "The year the album was released."
117
+
}
118
+
}
119
+
}
120
+
}
121
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_album_getAlbum.json
+30
crates/jacquard-api/lexicons/app_rocksky_album_getAlbum.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.album.getAlbum",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get detailed album view",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the album to retrieve.",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.album.defs#albumViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_album_getAlbumTracks.json
+38
crates/jacquard-api/lexicons/app_rocksky_album_getAlbumTracks.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.album.getAlbumTracks",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get tracks for an album",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the album to retrieve tracks from",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "object",
25
+
"properties": {
26
+
"tracks": {
27
+
"type": "array",
28
+
"items": {
29
+
"type": "ref",
30
+
"ref": "app.rocksky.song.defs#songViewBasic"
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+40
crates/jacquard-api/lexicons/app_rocksky_album_getAlbums.json
+40
crates/jacquard-api/lexicons/app_rocksky_album_getAlbums.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.album.getAlbums",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get albums",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The maximum number of albums to return",
14
+
"minimum": 1
15
+
},
16
+
"offset": {
17
+
"type": "integer",
18
+
"description": "The offset for pagination",
19
+
"minimum": 0
20
+
}
21
+
}
22
+
},
23
+
"output": {
24
+
"encoding": "application/json",
25
+
"schema": {
26
+
"type": "object",
27
+
"properties": {
28
+
"albums": {
29
+
"type": "array",
30
+
"items": {
31
+
"type": "ref",
32
+
"ref": "app.rocksky.album.defs#albumViewBasic"
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
+36
crates/jacquard-api/lexicons/app_rocksky_apikey_createApikey.json
+36
crates/jacquard-api/lexicons/app_rocksky_apikey_createApikey.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.apikey.createApikey",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Create a new API key for the authenticated user",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"name"
14
+
],
15
+
"properties": {
16
+
"description": {
17
+
"type": "string",
18
+
"description": "A description for the API key."
19
+
},
20
+
"name": {
21
+
"type": "string",
22
+
"description": "The name of the API key."
23
+
}
24
+
}
25
+
}
26
+
},
27
+
"output": {
28
+
"encoding": "application/json",
29
+
"schema": {
30
+
"type": "ref",
31
+
"ref": "app.rocksky.apikey.defs#apiKey"
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
+28
crates/jacquard-api/lexicons/app_rocksky_apikey_defs.json
+28
crates/jacquard-api/lexicons/app_rocksky_apikey_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.apikey.defs",
4
+
"defs": {
5
+
"apiKeyView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"createdAt": {
9
+
"type": "string",
10
+
"description": "The date and time when the API key was created.",
11
+
"format": "datetime"
12
+
},
13
+
"description": {
14
+
"type": "string",
15
+
"description": "A description for the API key."
16
+
},
17
+
"id": {
18
+
"type": "string",
19
+
"description": "The unique identifier of the API key."
20
+
},
21
+
"name": {
22
+
"type": "string",
23
+
"description": "The name of the API key."
24
+
}
25
+
}
26
+
}
27
+
}
28
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_apikey_getApikeys.json
+38
crates/jacquard-api/lexicons/app_rocksky_apikey_getApikeys.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.apikey.getApikeys",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a list of API keys for the authenticated user",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The number of API keys to return per page."
14
+
},
15
+
"offset": {
16
+
"type": "integer",
17
+
"description": "The number of API keys to skip before starting to collect the result set."
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "object",
25
+
"properties": {
26
+
"apiKeys": {
27
+
"type": "array",
28
+
"items": {
29
+
"type": "ref",
30
+
"ref": "app.rocksky.apikey.defs#apikeyView"
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_apikey_removeApikey.json
+29
crates/jacquard-api/lexicons/app_rocksky_apikey_removeApikey.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.apikey.removeApikey",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Remove an API key for the authenticated user",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"id"
12
+
],
13
+
"properties": {
14
+
"id": {
15
+
"type": "string",
16
+
"description": "The ID of the API key to remove."
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.apikey.defs#apiKey"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+41
crates/jacquard-api/lexicons/app_rocksky_apikey_updateApikey.json
+41
crates/jacquard-api/lexicons/app_rocksky_apikey_updateApikey.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.apikey.updateApikey",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Update an existing API key for the authenticated user",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"id",
14
+
"name"
15
+
],
16
+
"properties": {
17
+
"description": {
18
+
"type": "string",
19
+
"description": "A new description for the API key."
20
+
},
21
+
"id": {
22
+
"type": "string",
23
+
"description": "The ID of the API key to update."
24
+
},
25
+
"name": {
26
+
"type": "string",
27
+
"description": "The new name of the API key."
28
+
}
29
+
}
30
+
}
31
+
},
32
+
"output": {
33
+
"encoding": "application/json",
34
+
"schema": {
35
+
"type": "ref",
36
+
"ref": "app.rocksky.apikey.defs#apiKey"
37
+
}
38
+
}
39
+
}
40
+
}
41
+
}
+5
crates/jacquard-api/lexicons/app_rocksky_apikeys_defs.json
+5
crates/jacquard-api/lexicons/app_rocksky_apikeys_defs.json
+69
crates/jacquard-api/lexicons/app_rocksky_artist.json
+69
crates/jacquard-api/lexicons/app_rocksky_artist.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of an artist.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"name",
13
+
"createdAt"
14
+
],
15
+
"properties": {
16
+
"bio": {
17
+
"type": "string",
18
+
"description": "The biography of the artist.",
19
+
"maxLength": 1000
20
+
},
21
+
"born": {
22
+
"type": "string",
23
+
"description": "The birth date of the artist.",
24
+
"format": "datetime"
25
+
},
26
+
"bornIn": {
27
+
"type": "string",
28
+
"description": "The birth place of the artist.",
29
+
"maxLength": 256
30
+
},
31
+
"createdAt": {
32
+
"type": "string",
33
+
"description": "The date when the artist was created.",
34
+
"format": "datetime"
35
+
},
36
+
"died": {
37
+
"type": "string",
38
+
"description": "The death date of the artist.",
39
+
"format": "datetime"
40
+
},
41
+
"name": {
42
+
"type": "string",
43
+
"description": "The name of the artist.",
44
+
"minLength": 1,
45
+
"maxLength": 512
46
+
},
47
+
"picture": {
48
+
"type": "blob",
49
+
"description": "The picture of the artist.",
50
+
"accept": [
51
+
"image/png",
52
+
"image/jpeg"
53
+
],
54
+
"maxSize": 2000000
55
+
},
56
+
"tags": {
57
+
"type": "array",
58
+
"description": "The tags of the artist.",
59
+
"items": {
60
+
"type": "string",
61
+
"minLength": 1,
62
+
"maxLength": 256
63
+
}
64
+
}
65
+
}
66
+
}
67
+
}
68
+
}
69
+
}
+78
crates/jacquard-api/lexicons/app_rocksky_artist_defs.json
+78
crates/jacquard-api/lexicons/app_rocksky_artist_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist.defs",
4
+
"defs": {
5
+
"artistViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"id": {
9
+
"type": "string",
10
+
"description": "The unique identifier of the artist."
11
+
},
12
+
"name": {
13
+
"type": "string",
14
+
"description": "The name of the artist."
15
+
},
16
+
"picture": {
17
+
"type": "string",
18
+
"description": "The picture of the artist."
19
+
},
20
+
"playCount": {
21
+
"type": "integer",
22
+
"description": "The number of times the artist has been played.",
23
+
"minimum": 0
24
+
},
25
+
"sha256": {
26
+
"type": "string",
27
+
"description": "The SHA256 hash of the artist."
28
+
},
29
+
"uniqueListeners": {
30
+
"type": "integer",
31
+
"description": "The number of unique listeners who have played the artist.",
32
+
"minimum": 0
33
+
},
34
+
"uri": {
35
+
"type": "string",
36
+
"description": "The URI of the artist.",
37
+
"format": "at-uri"
38
+
}
39
+
}
40
+
},
41
+
"artistViewDetailed": {
42
+
"type": "object",
43
+
"properties": {
44
+
"id": {
45
+
"type": "string",
46
+
"description": "The unique identifier of the artist."
47
+
},
48
+
"name": {
49
+
"type": "string",
50
+
"description": "The name of the artist."
51
+
},
52
+
"picture": {
53
+
"type": "string",
54
+
"description": "The picture of the artist."
55
+
},
56
+
"playCount": {
57
+
"type": "integer",
58
+
"description": "The number of times the artist has been played.",
59
+
"minimum": 0
60
+
},
61
+
"sha256": {
62
+
"type": "string",
63
+
"description": "The SHA256 hash of the artist."
64
+
},
65
+
"uniqueListeners": {
66
+
"type": "integer",
67
+
"description": "The number of unique listeners who have played the artist.",
68
+
"minimum": 0
69
+
},
70
+
"uri": {
71
+
"type": "string",
72
+
"description": "The URI of the artist.",
73
+
"format": "at-uri"
74
+
}
75
+
}
76
+
}
77
+
}
78
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_artist_getArtist.json
+30
crates/jacquard-api/lexicons/app_rocksky_artist_getArtist.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist.getArtist",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get artist details",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the artist to retrieve details from",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.artist.defs#artistViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_artist_getArtistAlbums.json
+38
crates/jacquard-api/lexicons/app_rocksky_artist_getArtistAlbums.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist.getArtistAlbums",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get artist's albums",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the artist to retrieve albums from",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "object",
25
+
"properties": {
26
+
"albums": {
27
+
"type": "array",
28
+
"items": {
29
+
"type": "ref",
30
+
"ref": "app.rocksky.album.defs#albumViewBasic"
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+45
crates/jacquard-api/lexicons/app_rocksky_artist_getArtistTracks.json
+45
crates/jacquard-api/lexicons/app_rocksky_artist_getArtistTracks.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist.getArtistTracks",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get artist's tracks",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The maximum number of tracks to return",
14
+
"minimum": 1
15
+
},
16
+
"offset": {
17
+
"type": "integer",
18
+
"description": "The offset for pagination",
19
+
"minimum": 0
20
+
},
21
+
"uri": {
22
+
"type": "string",
23
+
"description": "The URI of the artist to retrieve albums from",
24
+
"format": "at-uri"
25
+
}
26
+
}
27
+
},
28
+
"output": {
29
+
"encoding": "application/json",
30
+
"schema": {
31
+
"type": "object",
32
+
"properties": {
33
+
"tracks": {
34
+
"type": "array",
35
+
"items": {
36
+
"type": "ref",
37
+
"ref": "app.rocksky.song.defs#songViewBasic"
38
+
}
39
+
}
40
+
}
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
+40
crates/jacquard-api/lexicons/app_rocksky_artist_getArtists.json
+40
crates/jacquard-api/lexicons/app_rocksky_artist_getArtists.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.artist.getArtists",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get artists",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The maximum number of artists to return",
14
+
"minimum": 1
15
+
},
16
+
"offset": {
17
+
"type": "integer",
18
+
"description": "The offset for pagination",
19
+
"minimum": 0
20
+
}
21
+
}
22
+
},
23
+
"output": {
24
+
"encoding": "application/json",
25
+
"schema": {
26
+
"type": "object",
27
+
"properties": {
28
+
"artists": {
29
+
"type": "array",
30
+
"items": {
31
+
"type": "ref",
32
+
"ref": "app.rocksky.artist.defs#artistViewBasic"
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
+32
crates/jacquard-api/lexicons/app_rocksky_charts_defs.json
+32
crates/jacquard-api/lexicons/app_rocksky_charts_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.charts.defs",
4
+
"defs": {
5
+
"chartsView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"scrobbles": {
9
+
"type": "array",
10
+
"items": {
11
+
"type": "ref",
12
+
"ref": "app.rocksky.charts.defs#scrobbleViewBasic"
13
+
}
14
+
}
15
+
}
16
+
},
17
+
"scrobbleViewBasic": {
18
+
"type": "object",
19
+
"properties": {
20
+
"count": {
21
+
"type": "integer",
22
+
"description": "The number of scrobbles on this date."
23
+
},
24
+
"date": {
25
+
"type": "string",
26
+
"description": "The date of the scrobble.",
27
+
"format": "datetime"
28
+
}
29
+
}
30
+
}
31
+
}
32
+
}
+42
crates/jacquard-api/lexicons/app_rocksky_charts_getScrobblesChart.json
+42
crates/jacquard-api/lexicons/app_rocksky_charts_getScrobblesChart.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.charts.getScrobblesChart",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get the scrobbles chart",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"albumuri": {
12
+
"type": "string",
13
+
"description": "The URI of the album to filter by",
14
+
"format": "at-uri"
15
+
},
16
+
"artisturi": {
17
+
"type": "string",
18
+
"description": "The URI of the artist to filter by",
19
+
"format": "at-uri"
20
+
},
21
+
"did": {
22
+
"type": "string",
23
+
"description": "The DID or handle of the actor",
24
+
"format": "at-identifier"
25
+
},
26
+
"songuri": {
27
+
"type": "string",
28
+
"description": "The URI of the track to filter by",
29
+
"format": "at-uri"
30
+
}
31
+
}
32
+
},
33
+
"output": {
34
+
"encoding": "application/json",
35
+
"schema": {
36
+
"type": "ref",
37
+
"ref": "app.rocksky.charts.defs#chartsView"
38
+
}
39
+
}
40
+
}
41
+
}
42
+
}
+60
crates/jacquard-api/lexicons/app_rocksky_dropbox_defs.json
+60
crates/jacquard-api/lexicons/app_rocksky_dropbox_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.dropbox.defs",
4
+
"defs": {
5
+
"fileListView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"files": {
9
+
"type": "array",
10
+
"description": "A list of files in the Dropbox.",
11
+
"items": {
12
+
"type": "ref",
13
+
"ref": "app.rocksky.dropbox.defs#fileView"
14
+
}
15
+
}
16
+
}
17
+
},
18
+
"fileView": {
19
+
"type": "object",
20
+
"properties": {
21
+
"clientModified": {
22
+
"type": "string",
23
+
"description": "The last modified date and time of the file on the client.",
24
+
"format": "datetime"
25
+
},
26
+
"id": {
27
+
"type": "string",
28
+
"description": "The unique identifier of the file."
29
+
},
30
+
"name": {
31
+
"type": "string",
32
+
"description": "The name of the file."
33
+
},
34
+
"pathDisplay": {
35
+
"type": "string",
36
+
"description": "The display path of the file."
37
+
},
38
+
"pathLower": {
39
+
"type": "string",
40
+
"description": "The lowercased path of the file."
41
+
},
42
+
"serverModified": {
43
+
"type": "string",
44
+
"description": "The last modified date and time of the file on the server.",
45
+
"format": "datetime"
46
+
}
47
+
}
48
+
},
49
+
"temporaryLinkView": {
50
+
"type": "object",
51
+
"properties": {
52
+
"link": {
53
+
"type": "string",
54
+
"description": "The temporary link to access the file.",
55
+
"format": "uri"
56
+
}
57
+
}
58
+
}
59
+
}
60
+
}
+25
crates/jacquard-api/lexicons/app_rocksky_dropbox_downloadFile.json
+25
crates/jacquard-api/lexicons/app_rocksky_dropbox_downloadFile.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.dropbox.downloadFile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Download a file from Dropbox by its unique identifier",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"fileId"
12
+
],
13
+
"properties": {
14
+
"fileId": {
15
+
"type": "string",
16
+
"description": "The unique identifier of the file to download"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/octet-stream"
22
+
}
23
+
}
24
+
}
25
+
}
+26
crates/jacquard-api/lexicons/app_rocksky_dropbox_getFiles.json
+26
crates/jacquard-api/lexicons/app_rocksky_dropbox_getFiles.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.dropbox.getFiles",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Retrieve a list of files from Dropbox",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"at": {
12
+
"type": "string",
13
+
"description": "Path to the Dropbox folder or root directory"
14
+
}
15
+
}
16
+
},
17
+
"output": {
18
+
"encoding": "application/json",
19
+
"schema": {
20
+
"type": "ref",
21
+
"ref": "app.rocksky.dropbox.defs#fileListView"
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_dropbox_getMetadata.json
+29
crates/jacquard-api/lexicons/app_rocksky_dropbox_getMetadata.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.dropbox.getMetadata",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Retrieve metadata of a file or folder in Dropbox",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"path"
12
+
],
13
+
"properties": {
14
+
"path": {
15
+
"type": "string",
16
+
"description": "Path to the file or folder in Dropbox"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.dropbox.defs#fileView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_dropbox_getTemporaryLink.json
+29
crates/jacquard-api/lexicons/app_rocksky_dropbox_getTemporaryLink.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.dropbox.getTemporaryLink",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Retrieve a temporary link to access a file in Dropbox",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"path"
12
+
],
13
+
"properties": {
14
+
"path": {
15
+
"type": "string",
16
+
"description": "Path to the file in Dropbox"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.dropbox.defs#temporaryLinkView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+105
crates/jacquard-api/lexicons/app_rocksky_feed_defs.json
+105
crates/jacquard-api/lexicons/app_rocksky_feed_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.feed.defs",
4
+
"defs": {
5
+
"nowPlayingView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"album": {
9
+
"type": "string"
10
+
},
11
+
"albumArt": {
12
+
"type": "string",
13
+
"format": "uri"
14
+
},
15
+
"albumArtist": {
16
+
"type": "string"
17
+
},
18
+
"albumUri": {
19
+
"type": "string",
20
+
"format": "at-uri"
21
+
},
22
+
"artist": {
23
+
"type": "string"
24
+
},
25
+
"artistUri": {
26
+
"type": "string",
27
+
"format": "at-uri"
28
+
},
29
+
"avatar": {
30
+
"type": "string",
31
+
"format": "uri"
32
+
},
33
+
"createdAt": {
34
+
"type": "string"
35
+
},
36
+
"did": {
37
+
"type": "string",
38
+
"format": "at-identifier"
39
+
},
40
+
"handle": {
41
+
"type": "string"
42
+
},
43
+
"id": {
44
+
"type": "string"
45
+
},
46
+
"title": {
47
+
"type": "string"
48
+
},
49
+
"trackId": {
50
+
"type": "string"
51
+
},
52
+
"trackUri": {
53
+
"type": "string",
54
+
"format": "at-uri"
55
+
},
56
+
"uri": {
57
+
"type": "string",
58
+
"format": "at-uri"
59
+
}
60
+
}
61
+
},
62
+
"nowPlayingsView": {
63
+
"type": "object",
64
+
"properties": {
65
+
"nowPlayings": {
66
+
"type": "array",
67
+
"items": {
68
+
"type": "ref",
69
+
"ref": "app.rocksky.feed.defs#nowPlayingView"
70
+
}
71
+
}
72
+
}
73
+
},
74
+
"searchResultsView": {
75
+
"type": "object",
76
+
"properties": {
77
+
"estimatedTotalHits": {
78
+
"type": "integer"
79
+
},
80
+
"hits": {
81
+
"type": "array",
82
+
"items": {
83
+
"type": "union",
84
+
"refs": [
85
+
"app.rocksky.song.defs#songViewBasic",
86
+
"app.rocksky.album.defs#albumViewBasic",
87
+
"app.rocksky.artist.defs#artistViewBasic",
88
+
"app.rocksky.playlist.defs#playlistViewBasic",
89
+
"app.rocksky.actor.defs#profileViewBasic"
90
+
]
91
+
}
92
+
},
93
+
"limit": {
94
+
"type": "integer"
95
+
},
96
+
"offset": {
97
+
"type": "integer"
98
+
},
99
+
"processingTimeMs": {
100
+
"type": "integer"
101
+
}
102
+
}
103
+
}
104
+
}
105
+
}
+27
crates/jacquard-api/lexicons/app_rocksky_feed_getNowPlayings.json
+27
crates/jacquard-api/lexicons/app_rocksky_feed_getNowPlayings.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.feed.getNowPlayings",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get all currently playing tracks by users",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"size": {
12
+
"type": "integer",
13
+
"description": "The maximum number of now playing tracks to return.",
14
+
"minimum": 1
15
+
}
16
+
}
17
+
},
18
+
"output": {
19
+
"encoding": "application/json",
20
+
"schema": {
21
+
"type": "ref",
22
+
"ref": "app.rocksky.feed.defs#nowPlayingsView"
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_feed_search.json
+29
crates/jacquard-api/lexicons/app_rocksky_feed_search.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.feed.search",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Search for content in the feed",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"query"
12
+
],
13
+
"properties": {
14
+
"query": {
15
+
"type": "string",
16
+
"description": "The search query string"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.feed.defs#searchResultsView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+27
crates/jacquard-api/lexicons/app_rocksky_googledrive_defs.json
+27
crates/jacquard-api/lexicons/app_rocksky_googledrive_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.googledrive.defs",
4
+
"defs": {
5
+
"fileListView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"files": {
9
+
"type": "array",
10
+
"items": {
11
+
"type": "ref",
12
+
"ref": "app.rocksky.googledrive.defs#fileView"
13
+
}
14
+
}
15
+
}
16
+
},
17
+
"fileView": {
18
+
"type": "object",
19
+
"properties": {
20
+
"id": {
21
+
"type": "string",
22
+
"description": "The unique identifier of the file."
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+25
crates/jacquard-api/lexicons/app_rocksky_googledrive_downloadFile.json
+25
crates/jacquard-api/lexicons/app_rocksky_googledrive_downloadFile.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.googledrive.downloadFile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Download a file from Google Drive by its unique identifier",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"fileId"
12
+
],
13
+
"properties": {
14
+
"fileId": {
15
+
"type": "string",
16
+
"description": "The unique identifier of the file to download"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/octet-stream"
22
+
}
23
+
}
24
+
}
25
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_googledrive_getFile.json
+29
crates/jacquard-api/lexicons/app_rocksky_googledrive_getFile.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.googledrive.getFile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a file from Google Drive by its unique identifier",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"fileId"
12
+
],
13
+
"properties": {
14
+
"fileId": {
15
+
"type": "string",
16
+
"description": "The unique identifier of the file to retrieve"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.googledrive.defs#fileView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+26
crates/jacquard-api/lexicons/app_rocksky_googledrive_getFiles.json
+26
crates/jacquard-api/lexicons/app_rocksky_googledrive_getFiles.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.googledrive.getFiles",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a list of files from Google Drive",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"at": {
12
+
"type": "string",
13
+
"description": "Path to the Google Drive folder or root directory"
14
+
}
15
+
}
16
+
},
17
+
"output": {
18
+
"encoding": "application/json",
19
+
"schema": {
20
+
"type": "ref",
21
+
"ref": "app.rocksky.googledrive.defs#fileListView"
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_like.json
+29
crates/jacquard-api/lexicons/app_rocksky_like.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.like",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a like.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"createdAt",
13
+
"subject"
14
+
],
15
+
"properties": {
16
+
"createdAt": {
17
+
"type": "string",
18
+
"description": "The date when the like was created.",
19
+
"format": "datetime"
20
+
},
21
+
"subject": {
22
+
"type": "ref",
23
+
"ref": "com.atproto.repo.strongRef"
24
+
}
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_like_dislikeShout.json
+30
crates/jacquard-api/lexicons/app_rocksky_like_dislikeShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.like.dislikeShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Dislike a shout",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"properties": {
13
+
"uri": {
14
+
"type": "string",
15
+
"description": "The unique identifier of the shout to dislike",
16
+
"format": "at-uri"
17
+
}
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.shout.defs#shoutView"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_like_dislikeSong.json
+30
crates/jacquard-api/lexicons/app_rocksky_like_dislikeSong.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.like.dislikeSong",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Dislike a song",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"properties": {
13
+
"uri": {
14
+
"type": "string",
15
+
"description": "The unique identifier of the song to dislike",
16
+
"format": "at-uri"
17
+
}
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.song.defs#songViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_like_likeShout.json
+30
crates/jacquard-api/lexicons/app_rocksky_like_likeShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.like.likeShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Like a shout",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"properties": {
13
+
"uri": {
14
+
"type": "string",
15
+
"description": "The unique identifier of the shout to like",
16
+
"format": "at-uri"
17
+
}
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.shout.defs#shoutView"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_like_likeSong.json
+30
crates/jacquard-api/lexicons/app_rocksky_like_likeSong.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.like.likeSong",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Like a song",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"properties": {
13
+
"uri": {
14
+
"type": "string",
15
+
"description": "The unique identifier of the song to like",
16
+
"format": "at-uri"
17
+
}
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.song.defs#songViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+15
crates/jacquard-api/lexicons/app_rocksky_player_defs.json
+15
crates/jacquard-api/lexicons/app_rocksky_player_defs.json
+27
crates/jacquard-api/lexicons/app_rocksky_player_getCurrentlyPlaying.json
+27
crates/jacquard-api/lexicons/app_rocksky_player_getCurrentlyPlaying.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.player.getCurrentlyPlaying",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get the currently playing track",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"actor": {
12
+
"type": "string",
13
+
"description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",
14
+
"format": "at-identifier"
15
+
}
16
+
}
17
+
},
18
+
"output": {
19
+
"encoding": "application/json",
20
+
"schema": {
21
+
"type": "ref",
22
+
"ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+10
crates/jacquard-api/lexicons/app_rocksky_player_next.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_next.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_pause.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_pause.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_play.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_play.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_previous.json
+10
crates/jacquard-api/lexicons/app_rocksky_player_previous.json
+22
crates/jacquard-api/lexicons/app_rocksky_player_seek.json
+22
crates/jacquard-api/lexicons/app_rocksky_player_seek.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.player.seek",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Seek to a specific position in the currently playing track",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"position"
12
+
],
13
+
"properties": {
14
+
"position": {
15
+
"type": "integer",
16
+
"description": "The position in seconds to seek to"
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
22
+
}
+70
crates/jacquard-api/lexicons/app_rocksky_playlist.json
+70
crates/jacquard-api/lexicons/app_rocksky_playlist.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.playlist",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a playlist.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"name",
13
+
"createdAt"
14
+
],
15
+
"properties": {
16
+
"appleMusicLink": {
17
+
"type": "string",
18
+
"description": "The Apple Music link of the playlist."
19
+
},
20
+
"createdAt": {
21
+
"type": "string",
22
+
"description": "The date the playlist was created.",
23
+
"format": "datetime"
24
+
},
25
+
"description": {
26
+
"type": "string",
27
+
"description": "The playlist description.",
28
+
"minLength": 1,
29
+
"maxLength": 256
30
+
},
31
+
"name": {
32
+
"type": "string",
33
+
"description": "The name of the playlist.",
34
+
"minLength": 1,
35
+
"maxLength": 512
36
+
},
37
+
"picture": {
38
+
"type": "blob",
39
+
"description": "The picture of the playlist.",
40
+
"accept": [
41
+
"image/png",
42
+
"image/jpeg"
43
+
],
44
+
"maxSize": 2000000
45
+
},
46
+
"spotifyLink": {
47
+
"type": "string",
48
+
"description": "The Spotify link of the playlist."
49
+
},
50
+
"tidalLink": {
51
+
"type": "string",
52
+
"description": "The Tidal link of the playlist."
53
+
},
54
+
"tracks": {
55
+
"type": "array",
56
+
"description": "The tracks in the playlist.",
57
+
"items": {
58
+
"type": "ref",
59
+
"ref": "app.rocksky.song#record"
60
+
}
61
+
},
62
+
"youtubeLink": {
63
+
"type": "string",
64
+
"description": "The YouTube link of the playlist."
65
+
}
66
+
}
67
+
}
68
+
}
69
+
}
70
+
}
+123
crates/jacquard-api/lexicons/app_rocksky_playlist_defs.json
+123
crates/jacquard-api/lexicons/app_rocksky_playlist_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.playlist.defs",
4
+
"defs": {
5
+
"playlistViewBasic": {
6
+
"type": "object",
7
+
"description": "Basic view of a playlist, including its metadata",
8
+
"properties": {
9
+
"coverImageUrl": {
10
+
"type": "string",
11
+
"description": "The URL of the cover image for the playlist.",
12
+
"format": "uri"
13
+
},
14
+
"createdAt": {
15
+
"type": "string",
16
+
"description": "The date and time when the playlist was created.",
17
+
"format": "datetime"
18
+
},
19
+
"curatorAvatarUrl": {
20
+
"type": "string",
21
+
"description": "The URL of the avatar image of the curator.",
22
+
"format": "uri"
23
+
},
24
+
"curatorDid": {
25
+
"type": "string",
26
+
"description": "The DID of the curator of the playlist.",
27
+
"format": "at-identifier"
28
+
},
29
+
"curatorHandle": {
30
+
"type": "string",
31
+
"description": "The handle of the curator of the playlist.",
32
+
"format": "at-identifier"
33
+
},
34
+
"curatorName": {
35
+
"type": "string",
36
+
"description": "The name of the curator of the playlist."
37
+
},
38
+
"description": {
39
+
"type": "string",
40
+
"description": "A description of the playlist."
41
+
},
42
+
"id": {
43
+
"type": "string",
44
+
"description": "The unique identifier of the playlist."
45
+
},
46
+
"title": {
47
+
"type": "string",
48
+
"description": "The title of the playlist."
49
+
},
50
+
"trackCount": {
51
+
"type": "integer",
52
+
"description": "The number of tracks in the playlist.",
53
+
"minimum": 0
54
+
},
55
+
"uri": {
56
+
"type": "string",
57
+
"description": "The URI of the playlist.",
58
+
"format": "at-uri"
59
+
}
60
+
}
61
+
},
62
+
"playlistViewDetailed": {
63
+
"type": "object",
64
+
"description": "Detailed view of a playlist, including its tracks and metadata",
65
+
"properties": {
66
+
"coverImageUrl": {
67
+
"type": "string",
68
+
"description": "The URL of the cover image for the playlist.",
69
+
"format": "uri"
70
+
},
71
+
"createdAt": {
72
+
"type": "string",
73
+
"description": "The date and time when the playlist was created.",
74
+
"format": "datetime"
75
+
},
76
+
"curatorAvatarUrl": {
77
+
"type": "string",
78
+
"description": "The URL of the avatar image of the curator.",
79
+
"format": "uri"
80
+
},
81
+
"curatorDid": {
82
+
"type": "string",
83
+
"description": "The DID of the curator of the playlist.",
84
+
"format": "at-identifier"
85
+
},
86
+
"curatorHandle": {
87
+
"type": "string",
88
+
"description": "The handle of the curator of the playlist.",
89
+
"format": "at-identifier"
90
+
},
91
+
"curatorName": {
92
+
"type": "string",
93
+
"description": "The name of the curator of the playlist."
94
+
},
95
+
"description": {
96
+
"type": "string",
97
+
"description": "A description of the playlist."
98
+
},
99
+
"id": {
100
+
"type": "string",
101
+
"description": "The unique identifier of the playlist."
102
+
},
103
+
"title": {
104
+
"type": "string",
105
+
"description": "The title of the playlist."
106
+
},
107
+
"tracks": {
108
+
"type": "array",
109
+
"description": "A list of tracks in the playlist.",
110
+
"items": {
111
+
"type": "ref",
112
+
"ref": "app.rocksky.song.defs#songViewBasic"
113
+
}
114
+
},
115
+
"uri": {
116
+
"type": "string",
117
+
"description": "The URI of the playlist.",
118
+
"format": "at-uri"
119
+
}
120
+
}
121
+
}
122
+
}
123
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylist.json
+30
crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylist.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.playlist.getPlaylist",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Retrieve a playlist by its ID",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the playlist to retrieve.",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.playlist.defs#playlistViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylists.json
+38
crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylists.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.playlist.getPlaylists",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Retrieve a list of playlists",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The maximum number of playlists to return."
14
+
},
15
+
"offset": {
16
+
"type": "integer",
17
+
"description": "The offset for pagination, used to skip a number of playlists."
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "object",
25
+
"properties": {
26
+
"playlists": {
27
+
"type": "array",
28
+
"items": {
29
+
"type": "ref",
30
+
"ref": "app.rocksky.playlist.defs#playlistViewBasic"
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+63
crates/jacquard-api/lexicons/app_rocksky_radio.json
+63
crates/jacquard-api/lexicons/app_rocksky_radio.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.radio",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a radio station.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"name",
13
+
"url",
14
+
"createdAt"
15
+
],
16
+
"properties": {
17
+
"createdAt": {
18
+
"type": "string",
19
+
"description": "The date when the radio station was created.",
20
+
"format": "datetime"
21
+
},
22
+
"description": {
23
+
"type": "string",
24
+
"description": "A description of the radio station.",
25
+
"minLength": 1,
26
+
"maxLength": 1000
27
+
},
28
+
"genre": {
29
+
"type": "string",
30
+
"description": "The genre of the radio station.",
31
+
"minLength": 1,
32
+
"maxLength": 256
33
+
},
34
+
"logo": {
35
+
"type": "blob",
36
+
"description": "The logo of the radio station.",
37
+
"accept": [
38
+
"image/png",
39
+
"image/jpeg"
40
+
],
41
+
"maxSize": 2000000
42
+
},
43
+
"name": {
44
+
"type": "string",
45
+
"description": "The name of the radio station.",
46
+
"minLength": 1,
47
+
"maxLength": 512
48
+
},
49
+
"url": {
50
+
"type": "string",
51
+
"description": "The URL of the radio station.",
52
+
"format": "uri"
53
+
},
54
+
"website": {
55
+
"type": "string",
56
+
"description": "The website of the radio station.",
57
+
"format": "uri"
58
+
}
59
+
}
60
+
}
61
+
}
62
+
}
63
+
}
+68
crates/jacquard-api/lexicons/app_rocksky_radio_defs.json
+68
crates/jacquard-api/lexicons/app_rocksky_radio_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.radio.defs",
4
+
"defs": {
5
+
"radioViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"createdAt": {
9
+
"type": "string",
10
+
"description": "The date and time when the radio was created.",
11
+
"format": "datetime"
12
+
},
13
+
"description": {
14
+
"type": "string",
15
+
"description": "A brief description of the radio."
16
+
},
17
+
"id": {
18
+
"type": "string",
19
+
"description": "The unique identifier of the radio."
20
+
},
21
+
"name": {
22
+
"type": "string",
23
+
"description": "The name of the radio."
24
+
}
25
+
}
26
+
},
27
+
"radioViewDetailed": {
28
+
"type": "object",
29
+
"properties": {
30
+
"createdAt": {
31
+
"type": "string",
32
+
"description": "The date and time when the radio was created.",
33
+
"format": "datetime"
34
+
},
35
+
"description": {
36
+
"type": "string",
37
+
"description": "A brief description of the radio."
38
+
},
39
+
"genre": {
40
+
"type": "string",
41
+
"description": "The genre of the radio."
42
+
},
43
+
"id": {
44
+
"type": "string",
45
+
"description": "The unique identifier of the radio."
46
+
},
47
+
"logo": {
48
+
"type": "string",
49
+
"description": "The logo of the radio station."
50
+
},
51
+
"name": {
52
+
"type": "string",
53
+
"description": "The name of the radio."
54
+
},
55
+
"url": {
56
+
"type": "string",
57
+
"description": "The streaming URL of the radio.",
58
+
"format": "uri"
59
+
},
60
+
"website": {
61
+
"type": "string",
62
+
"description": "The website of the radio.",
63
+
"format": "uri"
64
+
}
65
+
}
66
+
}
67
+
}
68
+
}
+149
crates/jacquard-api/lexicons/app_rocksky_scrobble.json
+149
crates/jacquard-api/lexicons/app_rocksky_scrobble.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.scrobble",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a scrobble.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"title",
13
+
"artist",
14
+
"album",
15
+
"albumArtist",
16
+
"duration",
17
+
"createdAt"
18
+
],
19
+
"properties": {
20
+
"album": {
21
+
"type": "string",
22
+
"description": "The album of the song.",
23
+
"minLength": 1,
24
+
"maxLength": 256
25
+
},
26
+
"albumArt": {
27
+
"type": "blob",
28
+
"description": "The album art of the song.",
29
+
"accept": [
30
+
"image/png",
31
+
"image/jpeg"
32
+
],
33
+
"maxSize": 2000000
34
+
},
35
+
"albumArtist": {
36
+
"type": "string",
37
+
"description": "The album artist of the song.",
38
+
"minLength": 1,
39
+
"maxLength": 256
40
+
},
41
+
"appleMusicLink": {
42
+
"type": "string",
43
+
"description": "The Apple Music link of the song.",
44
+
"format": "uri"
45
+
},
46
+
"artist": {
47
+
"type": "string",
48
+
"description": "The artist of the song.",
49
+
"minLength": 1,
50
+
"maxLength": 256
51
+
},
52
+
"composer": {
53
+
"type": "string",
54
+
"description": "The composer of the song.",
55
+
"maxLength": 256
56
+
},
57
+
"copyrightMessage": {
58
+
"type": "string",
59
+
"description": "The copyright message of the song.",
60
+
"maxLength": 256
61
+
},
62
+
"createdAt": {
63
+
"type": "string",
64
+
"description": "The date when the song was created.",
65
+
"format": "datetime"
66
+
},
67
+
"discNumber": {
68
+
"type": "integer",
69
+
"description": "The disc number of the song in the album.",
70
+
"minimum": 1
71
+
},
72
+
"duration": {
73
+
"type": "integer",
74
+
"description": "The duration of the song in seconds.",
75
+
"minimum": 1
76
+
},
77
+
"genre": {
78
+
"type": "string",
79
+
"description": "The genre of the song.",
80
+
"maxLength": 256
81
+
},
82
+
"label": {
83
+
"type": "string",
84
+
"description": "The label of the song.",
85
+
"maxLength": 256
86
+
},
87
+
"lyrics": {
88
+
"type": "string",
89
+
"description": "The lyrics of the song.",
90
+
"maxLength": 10000
91
+
},
92
+
"mbid": {
93
+
"type": "string",
94
+
"description": "The MusicBrainz ID of the song."
95
+
},
96
+
"releaseDate": {
97
+
"type": "string",
98
+
"description": "The release date of the song.",
99
+
"format": "datetime"
100
+
},
101
+
"spotifyLink": {
102
+
"type": "string",
103
+
"description": "The Spotify link of the song.",
104
+
"format": "uri"
105
+
},
106
+
"tags": {
107
+
"type": "array",
108
+
"description": "The tags of the song.",
109
+
"items": {
110
+
"type": "string",
111
+
"minLength": 1,
112
+
"maxLength": 256
113
+
}
114
+
},
115
+
"tidalLink": {
116
+
"type": "string",
117
+
"description": "The Tidal link of the song.",
118
+
"format": "uri"
119
+
},
120
+
"title": {
121
+
"type": "string",
122
+
"description": "The title of the song.",
123
+
"minLength": 1,
124
+
"maxLength": 512
125
+
},
126
+
"trackNumber": {
127
+
"type": "integer",
128
+
"description": "The track number of the song in the album.",
129
+
"minimum": 1
130
+
},
131
+
"wiki": {
132
+
"type": "string",
133
+
"description": "Informations about the song",
134
+
"maxLength": 10000
135
+
},
136
+
"year": {
137
+
"type": "integer",
138
+
"description": "The year the song was released."
139
+
},
140
+
"youtubeLink": {
141
+
"type": "string",
142
+
"description": "The YouTube link of the song.",
143
+
"format": "uri"
144
+
}
145
+
}
146
+
}
147
+
}
148
+
}
149
+
}
+125
crates/jacquard-api/lexicons/app_rocksky_scrobble_createScrobble.json
+125
crates/jacquard-api/lexicons/app_rocksky_scrobble_createScrobble.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.scrobble.createScrobble",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Create a new scrobble",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"title",
14
+
"artist"
15
+
],
16
+
"properties": {
17
+
"album": {
18
+
"type": "string",
19
+
"description": "The album of the track being scrobbled"
20
+
},
21
+
"albumArt": {
22
+
"type": "string",
23
+
"description": "The URL of the album art for the track",
24
+
"format": "uri"
25
+
},
26
+
"appleMusicLink": {
27
+
"type": "string",
28
+
"description": "The Apple Music link for the track, if available",
29
+
"format": "uri"
30
+
},
31
+
"artist": {
32
+
"type": "string",
33
+
"description": "The artist of the track being scrobbled"
34
+
},
35
+
"artistPicture": {
36
+
"type": "string",
37
+
"description": "The URL of the artist's picture, if available",
38
+
"format": "uri"
39
+
},
40
+
"composer": {
41
+
"type": "string",
42
+
"description": "The composer of the track, if available"
43
+
},
44
+
"copyrightMessage": {
45
+
"type": "string",
46
+
"description": "The copyright message for the track, if available"
47
+
},
48
+
"deezerLink": {
49
+
"type": "string",
50
+
"description": "The Deezer link for the track, if available",
51
+
"format": "uri"
52
+
},
53
+
"discNumber": {
54
+
"type": "integer",
55
+
"description": "The disc number of the track in the album, if applicable"
56
+
},
57
+
"duration": {
58
+
"type": "integer",
59
+
"description": "The duration of the track in seconds"
60
+
},
61
+
"label": {
62
+
"type": "string",
63
+
"description": "The record label of the track, if available"
64
+
},
65
+
"lastfmLink": {
66
+
"type": "string",
67
+
"description": "The Last.fm link for the track, if available",
68
+
"format": "uri"
69
+
},
70
+
"lyrics": {
71
+
"type": "string",
72
+
"description": "The lyrics of the track, if available"
73
+
},
74
+
"mbId": {
75
+
"type": "string",
76
+
"description": "The MusicBrainz ID of the track, if available"
77
+
},
78
+
"releaseDate": {
79
+
"type": "string",
80
+
"description": "The release date of the track, formatted as YYYY-MM-DD"
81
+
},
82
+
"spotifyLink": {
83
+
"type": "string",
84
+
"description": "The Spotify link for the track, if available",
85
+
"format": "uri"
86
+
},
87
+
"tidalLink": {
88
+
"type": "string",
89
+
"description": "The Tidal link for the track, if available",
90
+
"format": "uri"
91
+
},
92
+
"timestamp": {
93
+
"type": "integer",
94
+
"description": "The timestamp of the scrobble in milliseconds since epoch"
95
+
},
96
+
"title": {
97
+
"type": "string",
98
+
"description": "The title of the track being scrobbled"
99
+
},
100
+
"trackNumber": {
101
+
"type": "integer",
102
+
"description": "The track number of the track in the album"
103
+
},
104
+
"year": {
105
+
"type": "integer",
106
+
"description": "The year the track was released"
107
+
},
108
+
"youtubeLink": {
109
+
"type": "string",
110
+
"description": "The Youtube link for the track, if available",
111
+
"format": "uri"
112
+
}
113
+
}
114
+
}
115
+
},
116
+
"output": {
117
+
"encoding": "application/json",
118
+
"schema": {
119
+
"type": "ref",
120
+
"ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
121
+
}
122
+
}
123
+
}
124
+
}
125
+
}
+122
crates/jacquard-api/lexicons/app_rocksky_scrobble_defs.json
+122
crates/jacquard-api/lexicons/app_rocksky_scrobble_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.scrobble.defs",
4
+
"defs": {
5
+
"scrobbleViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"album": {
9
+
"type": "string",
10
+
"description": "The album of the song."
11
+
},
12
+
"albumUri": {
13
+
"type": "string",
14
+
"description": "The URI of the album.",
15
+
"format": "at-uri"
16
+
},
17
+
"artist": {
18
+
"type": "string",
19
+
"description": "The artist of the song."
20
+
},
21
+
"artistUri": {
22
+
"type": "string",
23
+
"description": "The URI of the artist.",
24
+
"format": "at-uri"
25
+
},
26
+
"cover": {
27
+
"type": "string",
28
+
"description": "The album art URL of the song.",
29
+
"format": "uri"
30
+
},
31
+
"date": {
32
+
"type": "string",
33
+
"description": "The timestamp when the scrobble was created.",
34
+
"format": "datetime"
35
+
},
36
+
"id": {
37
+
"type": "string",
38
+
"description": "The unique identifier of the scrobble."
39
+
},
40
+
"sha256": {
41
+
"type": "string",
42
+
"description": "The SHA256 hash of the scrobble data."
43
+
},
44
+
"title": {
45
+
"type": "string",
46
+
"description": "The title of the scrobble."
47
+
},
48
+
"uri": {
49
+
"type": "string",
50
+
"description": "The URI of the scrobble.",
51
+
"format": "uri"
52
+
},
53
+
"user": {
54
+
"type": "string",
55
+
"description": "The handle of the user who created the scrobble."
56
+
}
57
+
}
58
+
},
59
+
"scrobbleViewDetailed": {
60
+
"type": "object",
61
+
"properties": {
62
+
"album": {
63
+
"type": "string",
64
+
"description": "The album of the song."
65
+
},
66
+
"albumUri": {
67
+
"type": "string",
68
+
"description": "The URI of the album.",
69
+
"format": "at-uri"
70
+
},
71
+
"artist": {
72
+
"type": "string",
73
+
"description": "The artist of the song."
74
+
},
75
+
"artistUri": {
76
+
"type": "string",
77
+
"description": "The URI of the artist.",
78
+
"format": "at-uri"
79
+
},
80
+
"cover": {
81
+
"type": "string",
82
+
"description": "The album art URL of the song.",
83
+
"format": "uri"
84
+
},
85
+
"date": {
86
+
"type": "string",
87
+
"description": "The timestamp when the scrobble was created.",
88
+
"format": "datetime"
89
+
},
90
+
"id": {
91
+
"type": "string",
92
+
"description": "The unique identifier of the scrobble."
93
+
},
94
+
"listeners": {
95
+
"type": "integer",
96
+
"description": "The number of listeners"
97
+
},
98
+
"scrobbles": {
99
+
"type": "integer",
100
+
"description": "The number of scrobbles for this song"
101
+
},
102
+
"sha256": {
103
+
"type": "string",
104
+
"description": "The SHA256 hash of the scrobble data."
105
+
},
106
+
"title": {
107
+
"type": "string",
108
+
"description": "The title of the scrobble."
109
+
},
110
+
"uri": {
111
+
"type": "string",
112
+
"description": "The URI of the scrobble.",
113
+
"format": "uri"
114
+
},
115
+
"user": {
116
+
"type": "string",
117
+
"description": "The handle of the user who created the scrobble."
118
+
}
119
+
}
120
+
}
121
+
}
122
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobble.json
+30
crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobble.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.scrobble.getScrobble",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a scrobble by its unique identifier",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The unique identifier of the scrobble",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.scrobble.defs#scrobbleViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+45
crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobbles.json
+45
crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobbles.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.scrobble.getScrobbles",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get scrobbles all scrobbles",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"did": {
12
+
"type": "string",
13
+
"description": "The DID or handle of the actor",
14
+
"format": "at-identifier"
15
+
},
16
+
"limit": {
17
+
"type": "integer",
18
+
"description": "The maximum number of scrobbles to return",
19
+
"minimum": 1
20
+
},
21
+
"offset": {
22
+
"type": "integer",
23
+
"description": "The offset for pagination",
24
+
"minimum": 0
25
+
}
26
+
}
27
+
},
28
+
"output": {
29
+
"encoding": "application/json",
30
+
"schema": {
31
+
"type": "object",
32
+
"properties": {
33
+
"scrobbles": {
34
+
"type": "array",
35
+
"items": {
36
+
"type": "ref",
37
+
"ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"
38
+
}
39
+
}
40
+
}
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
+40
crates/jacquard-api/lexicons/app_rocksky_shout.json
+40
crates/jacquard-api/lexicons/app_rocksky_shout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a shout.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"message",
13
+
"createdAt",
14
+
"subject"
15
+
],
16
+
"properties": {
17
+
"createdAt": {
18
+
"type": "string",
19
+
"description": "The date when the shout was created.",
20
+
"format": "datetime"
21
+
},
22
+
"message": {
23
+
"type": "string",
24
+
"description": "The message of the shout.",
25
+
"minLength": 1,
26
+
"maxLength": 1000
27
+
},
28
+
"parent": {
29
+
"type": "ref",
30
+
"ref": "com.atproto.repo.strongRef"
31
+
},
32
+
"subject": {
33
+
"type": "ref",
34
+
"ref": "com.atproto.repo.strongRef"
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_shout_createShout.json
+30
crates/jacquard-api/lexicons/app_rocksky_shout_createShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.createShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Create a new shout",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"properties": {
13
+
"message": {
14
+
"type": "string",
15
+
"description": "The content of the shout",
16
+
"minLength": 1
17
+
}
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.shout.defs#shoutView"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+61
crates/jacquard-api/lexicons/app_rocksky_shout_defs.json
+61
crates/jacquard-api/lexicons/app_rocksky_shout_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.defs",
4
+
"defs": {
5
+
"author": {
6
+
"type": "object",
7
+
"properties": {
8
+
"avatar": {
9
+
"type": "string",
10
+
"description": "The URL of the author's avatar image.",
11
+
"format": "uri"
12
+
},
13
+
"did": {
14
+
"type": "string",
15
+
"description": "The decentralized identifier (DID) of the author.",
16
+
"format": "at-identifier"
17
+
},
18
+
"displayName": {
19
+
"type": "string",
20
+
"description": "The display name of the author."
21
+
},
22
+
"handle": {
23
+
"type": "string",
24
+
"description": "The handle of the author.",
25
+
"format": "at-identifier"
26
+
},
27
+
"id": {
28
+
"type": "string",
29
+
"description": "The unique identifier of the author."
30
+
}
31
+
}
32
+
},
33
+
"shoutView": {
34
+
"type": "object",
35
+
"properties": {
36
+
"author": {
37
+
"type": "ref",
38
+
"description": "The author of the shout.",
39
+
"ref": "app.rocksky.shout.defs#author"
40
+
},
41
+
"createdAt": {
42
+
"type": "string",
43
+
"description": "The date and time when the shout was created.",
44
+
"format": "datetime"
45
+
},
46
+
"id": {
47
+
"type": "string",
48
+
"description": "The unique identifier of the shout."
49
+
},
50
+
"message": {
51
+
"type": "string",
52
+
"description": "The content of the shout."
53
+
},
54
+
"parent": {
55
+
"type": "string",
56
+
"description": "The ID of the parent shout if this is a reply, otherwise null."
57
+
}
58
+
}
59
+
}
60
+
}
61
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getAlbumShouts.json
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getAlbumShouts.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.getAlbumShouts",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get shouts for an album",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"limit": {
15
+
"type": "integer",
16
+
"description": "The maximum number of shouts to return",
17
+
"minimum": 1
18
+
},
19
+
"offset": {
20
+
"type": "integer",
21
+
"description": "The number of shouts to skip before starting to collect the result set",
22
+
"minimum": 0
23
+
},
24
+
"uri": {
25
+
"type": "string",
26
+
"description": "The unique identifier of the album to retrieve shouts for",
27
+
"format": "at-uri"
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"shouts": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.shout.defs#shoutViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getArtistShouts.json
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getArtistShouts.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.getArtistShouts",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get shouts for an artist",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"limit": {
15
+
"type": "integer",
16
+
"description": "The maximum number of shouts to return",
17
+
"minimum": 1
18
+
},
19
+
"offset": {
20
+
"type": "integer",
21
+
"description": "The number of shouts to skip before starting to collect the result set",
22
+
"minimum": 0
23
+
},
24
+
"uri": {
25
+
"type": "string",
26
+
"description": "The URI of the artist to retrieve shouts for",
27
+
"format": "at-uri"
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"shouts": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.shout.defs#shoutViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getProfileShouts.json
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getProfileShouts.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.getProfileShouts",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get the shouts of an actor's profile",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"did"
12
+
],
13
+
"properties": {
14
+
"did": {
15
+
"type": "string",
16
+
"description": "The DID or handle of the actor",
17
+
"format": "at-identifier"
18
+
},
19
+
"limit": {
20
+
"type": "integer",
21
+
"description": "The maximum number of shouts to return",
22
+
"minimum": 1
23
+
},
24
+
"offset": {
25
+
"type": "integer",
26
+
"description": "The offset for pagination",
27
+
"minimum": 0
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"shouts": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.shout.defs#shoutViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getShoutReplies.json
+48
crates/jacquard-api/lexicons/app_rocksky_shout_getShoutReplies.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.getShoutReplies",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get replies to a shout",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"limit": {
15
+
"type": "integer",
16
+
"description": "The maximum number of shouts to return",
17
+
"minimum": 1
18
+
},
19
+
"offset": {
20
+
"type": "integer",
21
+
"description": "The number of shouts to skip before starting to collect the result set",
22
+
"minimum": 0
23
+
},
24
+
"uri": {
25
+
"type": "string",
26
+
"description": "The URI of the shout to retrieve replies for",
27
+
"format": "at-uri"
28
+
}
29
+
}
30
+
},
31
+
"output": {
32
+
"encoding": "application/json",
33
+
"schema": {
34
+
"type": "object",
35
+
"properties": {
36
+
"shouts": {
37
+
"type": "array",
38
+
"items": {
39
+
"type": "ref",
40
+
"ref": "app.rocksky.shout.defs#shoutViewBasic"
41
+
}
42
+
}
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_shout_getTrackShouts.json
+38
crates/jacquard-api/lexicons/app_rocksky_shout_getTrackShouts.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.getTrackShouts",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get all shouts for a specific track",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The URI of the track to retrieve shouts for",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "object",
25
+
"properties": {
26
+
"shouts": {
27
+
"type": "array",
28
+
"items": {
29
+
"type": "ref",
30
+
"ref": "app.rocksky.shout.defs#shoutViewBasic"
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_shout_removeShout.json
+29
crates/jacquard-api/lexicons/app_rocksky_shout_removeShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.removeShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Remove a shout by its ID",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"id"
12
+
],
13
+
"properties": {
14
+
"id": {
15
+
"type": "string",
16
+
"description": "The ID of the shout to be removed"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.shout.defs#shoutView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+38
crates/jacquard-api/lexicons/app_rocksky_shout_replyShout.json
+38
crates/jacquard-api/lexicons/app_rocksky_shout_replyShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.replyShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Reply to a shout",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"shoutId",
14
+
"message"
15
+
],
16
+
"properties": {
17
+
"message": {
18
+
"type": "string",
19
+
"description": "The content of the reply",
20
+
"minLength": 1
21
+
},
22
+
"shoutId": {
23
+
"type": "string",
24
+
"description": "The unique identifier of the shout to reply to"
25
+
}
26
+
}
27
+
}
28
+
},
29
+
"output": {
30
+
"encoding": "application/json",
31
+
"schema": {
32
+
"type": "ref",
33
+
"ref": "app.rocksky.shout.defs#shoutView"
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
+37
crates/jacquard-api/lexicons/app_rocksky_shout_reportShout.json
+37
crates/jacquard-api/lexicons/app_rocksky_shout_reportShout.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.shout.reportShout",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Report a shout for moderation",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"shoutId"
14
+
],
15
+
"properties": {
16
+
"reason": {
17
+
"type": "string",
18
+
"description": "The reason for reporting the shout",
19
+
"minLength": 1
20
+
},
21
+
"shoutId": {
22
+
"type": "string",
23
+
"description": "The unique identifier of the shout to report"
24
+
}
25
+
}
26
+
}
27
+
},
28
+
"output": {
29
+
"encoding": "application/json",
30
+
"schema": {
31
+
"type": "ref",
32
+
"ref": "app.rocksky.shout.defs#shoutView"
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
+150
crates/jacquard-api/lexicons/app_rocksky_song.json
+150
crates/jacquard-api/lexicons/app_rocksky_song.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.song",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "A declaration of a song.",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": [
12
+
"title",
13
+
"artist",
14
+
"album",
15
+
"albumArtist",
16
+
"duration",
17
+
"createdAt"
18
+
],
19
+
"properties": {
20
+
"album": {
21
+
"type": "string",
22
+
"description": "The album of the song.",
23
+
"minLength": 1,
24
+
"maxLength": 256
25
+
},
26
+
"albumArt": {
27
+
"type": "blob",
28
+
"description": "The album art of the song.",
29
+
"accept": [
30
+
"image/png",
31
+
"image/jpeg"
32
+
],
33
+
"maxSize": 2000000
34
+
},
35
+
"albumArtist": {
36
+
"type": "string",
37
+
"description": "The album artist of the song.",
38
+
"minLength": 1,
39
+
"maxLength": 256
40
+
},
41
+
"appleMusicLink": {
42
+
"type": "string",
43
+
"description": "The Apple Music link of the song.",
44
+
"format": "uri"
45
+
},
46
+
"artist": {
47
+
"type": "string",
48
+
"description": "The artist of the song.",
49
+
"minLength": 1,
50
+
"maxLength": 256
51
+
},
52
+
"composer": {
53
+
"type": "string",
54
+
"description": "The composer of the song.",
55
+
"maxLength": 256
56
+
},
57
+
"copyrightMessage": {
58
+
"type": "string",
59
+
"description": "The copyright message of the song.",
60
+
"maxLength": 256
61
+
},
62
+
"createdAt": {
63
+
"type": "string",
64
+
"description": "The date when the song was created.",
65
+
"format": "datetime"
66
+
},
67
+
"discNumber": {
68
+
"type": "integer",
69
+
"description": "The disc number of the song in the album.",
70
+
"minimum": 1
71
+
},
72
+
"duration": {
73
+
"type": "integer",
74
+
"description": "The duration of the song in seconds.",
75
+
"minimum": 1
76
+
},
77
+
"genre": {
78
+
"type": "string",
79
+
"description": "The genre of the song.",
80
+
"minLength": 1,
81
+
"maxLength": 256
82
+
},
83
+
"label": {
84
+
"type": "string",
85
+
"description": "The label of the song.",
86
+
"maxLength": 256
87
+
},
88
+
"lyrics": {
89
+
"type": "string",
90
+
"description": "The lyrics of the song.",
91
+
"maxLength": 10000
92
+
},
93
+
"mbid": {
94
+
"type": "string",
95
+
"description": "The MusicBrainz ID of the song."
96
+
},
97
+
"releaseDate": {
98
+
"type": "string",
99
+
"description": "The release date of the song.",
100
+
"format": "datetime"
101
+
},
102
+
"spotifyLink": {
103
+
"type": "string",
104
+
"description": "The Spotify link of the song.",
105
+
"format": "uri"
106
+
},
107
+
"tags": {
108
+
"type": "array",
109
+
"description": "The tags of the song.",
110
+
"items": {
111
+
"type": "string",
112
+
"minLength": 1,
113
+
"maxLength": 256
114
+
}
115
+
},
116
+
"tidalLink": {
117
+
"type": "string",
118
+
"description": "The Tidal link of the song.",
119
+
"format": "uri"
120
+
},
121
+
"title": {
122
+
"type": "string",
123
+
"description": "The title of the song.",
124
+
"minLength": 1,
125
+
"maxLength": 512
126
+
},
127
+
"trackNumber": {
128
+
"type": "integer",
129
+
"description": "The track number of the song in the album.",
130
+
"minimum": 1
131
+
},
132
+
"wiki": {
133
+
"type": "string",
134
+
"description": "Informations about the song",
135
+
"maxLength": 10000
136
+
},
137
+
"year": {
138
+
"type": "integer",
139
+
"description": "The year the song was released."
140
+
},
141
+
"youtubeLink": {
142
+
"type": "string",
143
+
"description": "The YouTube link of the song.",
144
+
"format": "uri"
145
+
}
146
+
}
147
+
}
148
+
}
149
+
}
150
+
}
+80
crates/jacquard-api/lexicons/app_rocksky_song_createSong.json
+80
crates/jacquard-api/lexicons/app_rocksky_song_createSong.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.song.createSong",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Create a new song",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": [
13
+
"title",
14
+
"artist",
15
+
"album",
16
+
"albumArtist"
17
+
],
18
+
"properties": {
19
+
"album": {
20
+
"type": "string",
21
+
"description": "The album of the song, if applicable"
22
+
},
23
+
"albumArt": {
24
+
"type": "string",
25
+
"description": "The URL of the album art for the song",
26
+
"format": "uri"
27
+
},
28
+
"albumArtist": {
29
+
"type": "string",
30
+
"description": "The album artist of the song, if different from the main artist"
31
+
},
32
+
"artist": {
33
+
"type": "string",
34
+
"description": "The artist of the song"
35
+
},
36
+
"discNumber": {
37
+
"type": "integer",
38
+
"description": "The disc number of the song in the album, if applicable"
39
+
},
40
+
"duration": {
41
+
"type": "integer",
42
+
"description": "The duration of the song in seconds"
43
+
},
44
+
"lyrics": {
45
+
"type": "string",
46
+
"description": "The lyrics of the song, if available"
47
+
},
48
+
"mbId": {
49
+
"type": "string",
50
+
"description": "The MusicBrainz ID of the song, if available"
51
+
},
52
+
"releaseDate": {
53
+
"type": "string",
54
+
"description": "The release date of the song, formatted as YYYY-MM-DD"
55
+
},
56
+
"title": {
57
+
"type": "string",
58
+
"description": "The title of the song"
59
+
},
60
+
"trackNumber": {
61
+
"type": "integer",
62
+
"description": "The track number of the song in the album, if applicable"
63
+
},
64
+
"year": {
65
+
"type": "integer",
66
+
"description": "The year the song was released"
67
+
}
68
+
}
69
+
}
70
+
},
71
+
"output": {
72
+
"encoding": "application/json",
73
+
"schema": {
74
+
"type": "ref",
75
+
"ref": "app.rocksky.song.defs#songViewDetailed"
76
+
}
77
+
}
78
+
}
79
+
}
80
+
}
+158
crates/jacquard-api/lexicons/app_rocksky_song_defs.json
+158
crates/jacquard-api/lexicons/app_rocksky_song_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.song.defs",
4
+
"defs": {
5
+
"songViewBasic": {
6
+
"type": "object",
7
+
"properties": {
8
+
"album": {
9
+
"type": "string",
10
+
"description": "The album of the song."
11
+
},
12
+
"albumArt": {
13
+
"type": "string",
14
+
"description": "The URL of the album art image.",
15
+
"format": "uri"
16
+
},
17
+
"albumArtist": {
18
+
"type": "string",
19
+
"description": "The artist of the album the song belongs to."
20
+
},
21
+
"albumUri": {
22
+
"type": "string",
23
+
"description": "The URI of the album the song belongs to.",
24
+
"format": "at-uri"
25
+
},
26
+
"artist": {
27
+
"type": "string",
28
+
"description": "The artist of the song."
29
+
},
30
+
"artistUri": {
31
+
"type": "string",
32
+
"description": "The URI of the artist of the song.",
33
+
"format": "at-uri"
34
+
},
35
+
"createdAt": {
36
+
"type": "string",
37
+
"description": "The timestamp when the song was created.",
38
+
"format": "datetime"
39
+
},
40
+
"discNumber": {
41
+
"type": "integer",
42
+
"description": "The disc number of the song in the album."
43
+
},
44
+
"duration": {
45
+
"type": "integer",
46
+
"description": "The duration of the song in milliseconds."
47
+
},
48
+
"id": {
49
+
"type": "string",
50
+
"description": "The unique identifier of the song."
51
+
},
52
+
"playCount": {
53
+
"type": "integer",
54
+
"description": "The number of times the song has been played.",
55
+
"minimum": 0
56
+
},
57
+
"sha256": {
58
+
"type": "string",
59
+
"description": "The SHA256 hash of the song."
60
+
},
61
+
"title": {
62
+
"type": "string",
63
+
"description": "The title of the song."
64
+
},
65
+
"trackNumber": {
66
+
"type": "integer",
67
+
"description": "The track number of the song in the album."
68
+
},
69
+
"uniqueListeners": {
70
+
"type": "integer",
71
+
"description": "The number of unique listeners who have played the song.",
72
+
"minimum": 0
73
+
},
74
+
"uri": {
75
+
"type": "string",
76
+
"description": "The URI of the song.",
77
+
"format": "at-uri"
78
+
}
79
+
}
80
+
},
81
+
"songViewDetailed": {
82
+
"type": "object",
83
+
"properties": {
84
+
"album": {
85
+
"type": "string",
86
+
"description": "The album of the song."
87
+
},
88
+
"albumArt": {
89
+
"type": "string",
90
+
"description": "The URL of the album art image.",
91
+
"format": "uri"
92
+
},
93
+
"albumArtist": {
94
+
"type": "string",
95
+
"description": "The artist of the album the song belongs to."
96
+
},
97
+
"albumUri": {
98
+
"type": "string",
99
+
"description": "The URI of the album the song belongs to.",
100
+
"format": "at-uri"
101
+
},
102
+
"artist": {
103
+
"type": "string",
104
+
"description": "The artist of the song."
105
+
},
106
+
"artistUri": {
107
+
"type": "string",
108
+
"description": "The URI of the artist of the song.",
109
+
"format": "at-uri"
110
+
},
111
+
"createdAt": {
112
+
"type": "string",
113
+
"description": "The timestamp when the song was created.",
114
+
"format": "datetime"
115
+
},
116
+
"discNumber": {
117
+
"type": "integer",
118
+
"description": "The disc number of the song in the album."
119
+
},
120
+
"duration": {
121
+
"type": "integer",
122
+
"description": "The duration of the song in milliseconds."
123
+
},
124
+
"id": {
125
+
"type": "string",
126
+
"description": "The unique identifier of the song."
127
+
},
128
+
"playCount": {
129
+
"type": "integer",
130
+
"description": "The number of times the song has been played.",
131
+
"minimum": 0
132
+
},
133
+
"sha256": {
134
+
"type": "string",
135
+
"description": "The SHA256 hash of the song."
136
+
},
137
+
"title": {
138
+
"type": "string",
139
+
"description": "The title of the song."
140
+
},
141
+
"trackNumber": {
142
+
"type": "integer",
143
+
"description": "The track number of the song in the album."
144
+
},
145
+
"uniqueListeners": {
146
+
"type": "integer",
147
+
"description": "The number of unique listeners who have played the song.",
148
+
"minimum": 0
149
+
},
150
+
"uri": {
151
+
"type": "string",
152
+
"description": "The URI of the song.",
153
+
"format": "at-uri"
154
+
}
155
+
}
156
+
}
157
+
}
158
+
}
+30
crates/jacquard-api/lexicons/app_rocksky_song_getSong.json
+30
crates/jacquard-api/lexicons/app_rocksky_song_getSong.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.song.getSong",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a song by its uri",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"uri"
12
+
],
13
+
"properties": {
14
+
"uri": {
15
+
"type": "string",
16
+
"description": "The unique identifier of the song to retrieve",
17
+
"format": "at-uri"
18
+
}
19
+
}
20
+
},
21
+
"output": {
22
+
"encoding": "application/json",
23
+
"schema": {
24
+
"type": "ref",
25
+
"ref": "app.rocksky.song.defs#songViewDetailed"
26
+
}
27
+
}
28
+
}
29
+
}
30
+
}
+40
crates/jacquard-api/lexicons/app_rocksky_song_getSongs.json
+40
crates/jacquard-api/lexicons/app_rocksky_song_getSongs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.song.getSongs",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get songs",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"limit": {
12
+
"type": "integer",
13
+
"description": "The maximum number of songs to return",
14
+
"minimum": 1
15
+
},
16
+
"offset": {
17
+
"type": "integer",
18
+
"description": "The offset for pagination",
19
+
"minimum": 0
20
+
}
21
+
}
22
+
},
23
+
"output": {
24
+
"encoding": "application/json",
25
+
"schema": {
26
+
"type": "object",
27
+
"properties": {
28
+
"songs": {
29
+
"type": "array",
30
+
"items": {
31
+
"type": "ref",
32
+
"ref": "app.rocksky.song.defs#songViewBasic"
33
+
}
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
+35
crates/jacquard-api/lexicons/app_rocksky_spotify_defs.json
+35
crates/jacquard-api/lexicons/app_rocksky_spotify_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.spotify.defs",
4
+
"defs": {
5
+
"spotifyTrackView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"album": {
9
+
"type": "string",
10
+
"description": "The name of the album."
11
+
},
12
+
"artist": {
13
+
"type": "string",
14
+
"description": "The name of the artist."
15
+
},
16
+
"duration": {
17
+
"type": "integer",
18
+
"description": "The duration of the track in milliseconds."
19
+
},
20
+
"id": {
21
+
"type": "string",
22
+
"description": "The unique identifier of the Spotify track."
23
+
},
24
+
"name": {
25
+
"type": "string",
26
+
"description": "The name of the track."
27
+
},
28
+
"previewUrl": {
29
+
"type": "string",
30
+
"description": "A URL to a preview of the track."
31
+
}
32
+
}
33
+
}
34
+
}
35
+
}
+27
crates/jacquard-api/lexicons/app_rocksky_spotify_getCurrentlyPlaying.json
+27
crates/jacquard-api/lexicons/app_rocksky_spotify_getCurrentlyPlaying.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.spotify.getCurrentlyPlaying",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get the currently playing track",
8
+
"parameters": {
9
+
"type": "params",
10
+
"properties": {
11
+
"actor": {
12
+
"type": "string",
13
+
"description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",
14
+
"format": "at-identifier"
15
+
}
16
+
}
17
+
},
18
+
"output": {
19
+
"encoding": "application/json",
20
+
"schema": {
21
+
"type": "ref",
22
+
"ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_next.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_next.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_pause.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_pause.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_play.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_play.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_previous.json
+10
crates/jacquard-api/lexicons/app_rocksky_spotify_previous.json
+22
crates/jacquard-api/lexicons/app_rocksky_spotify_seek.json
+22
crates/jacquard-api/lexicons/app_rocksky_spotify_seek.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.spotify.seek",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Seek to a specific position in the currently playing track",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": [
11
+
"position"
12
+
],
13
+
"properties": {
14
+
"position": {
15
+
"type": "integer",
16
+
"description": "The position in seconds to seek to"
17
+
}
18
+
}
19
+
}
20
+
}
21
+
}
22
+
}
+31
crates/jacquard-api/lexicons/app_rocksky_stats_defs.json
+31
crates/jacquard-api/lexicons/app_rocksky_stats_defs.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.stats.defs",
4
+
"defs": {
5
+
"statsView": {
6
+
"type": "object",
7
+
"properties": {
8
+
"albums": {
9
+
"type": "integer",
10
+
"description": "The total number of unique albums scrobbled."
11
+
},
12
+
"artists": {
13
+
"type": "integer",
14
+
"description": "The total number of unique artists scrobbled."
15
+
},
16
+
"lovedTracks": {
17
+
"type": "integer",
18
+
"description": "The total number of tracks marked as loved."
19
+
},
20
+
"scrobbles": {
21
+
"type": "integer",
22
+
"description": "The total number of scrobbles."
23
+
},
24
+
"tracks": {
25
+
"type": "integer",
26
+
"description": "The total number of unique tracks scrobbled."
27
+
}
28
+
}
29
+
}
30
+
}
31
+
}
+29
crates/jacquard-api/lexicons/app_rocksky_stats_getStats.json
+29
crates/jacquard-api/lexicons/app_rocksky_stats_getStats.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.rocksky.stats.getStats",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"parameters": {
8
+
"type": "params",
9
+
"required": [
10
+
"did"
11
+
],
12
+
"properties": {
13
+
"did": {
14
+
"type": "string",
15
+
"description": "The DID or handle of the user to get stats for.",
16
+
"format": "at-identifier"
17
+
}
18
+
}
19
+
},
20
+
"output": {
21
+
"encoding": "application/json",
22
+
"schema": {
23
+
"type": "ref",
24
+
"ref": "app.rocksky.stats.defs#statsView"
25
+
}
26
+
}
27
+
}
28
+
}
29
+
}
+106
crates/jacquard-api/lexicons/net_altq_aqfile.json
+106
crates/jacquard-api/lexicons/net_altq_aqfile.json
···
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "net.altq.aqfile",
4
+
"description": "A record for uploading and tracking binary blob files with metadata.",
5
+
"defs": {
6
+
"checksum": {
7
+
"type": "object",
8
+
"description": "Cryptographic checksum for integrity verification.",
9
+
"required": [
10
+
"algo",
11
+
"hash"
12
+
],
13
+
"properties": {
14
+
"algo": {
15
+
"type": "string",
16
+
"description": "Hash algorithm name.",
17
+
"maxLength": 32,
18
+
"knownValues": [
19
+
"sha256",
20
+
"sha512",
21
+
"blake3"
22
+
]
23
+
},
24
+
"hash": {
25
+
"type": "string",
26
+
"description": "Hex or base64 encoded digest produced by the algorithm.",
27
+
"maxLength": 128
28
+
}
29
+
}
30
+
},
31
+
"file": {
32
+
"type": "object",
33
+
"description": "File metadata describing the uploaded blob.",
34
+
"required": [
35
+
"name",
36
+
"size"
37
+
],
38
+
"properties": {
39
+
"mimeType": {
40
+
"type": "string",
41
+
"description": "MIME type, e.g. 'video/mp4'.",
42
+
"maxLength": 255
43
+
},
44
+
"modifiedAt": {
45
+
"type": "string",
46
+
"description": "Client-side last-modified timestamp.",
47
+
"format": "datetime"
48
+
},
49
+
"name": {
50
+
"type": "string",
51
+
"description": "User-visible filename.",
52
+
"maxLength": 512
53
+
},
54
+
"size": {
55
+
"type": "integer",
56
+
"description": "File size in bytes.",
57
+
"minimum": 0,
58
+
"maximum": 1000000000
59
+
}
60
+
}
61
+
},
62
+
"main": {
63
+
"type": "record",
64
+
"description": "A record representing an uploaded file blob with metadata.",
65
+
"key": "any",
66
+
"record": {
67
+
"type": "object",
68
+
"required": [
69
+
"blob",
70
+
"createdAt",
71
+
"file"
72
+
],
73
+
"properties": {
74
+
"attribution": {
75
+
"type": "string",
76
+
"description": "Handle or DID of the account to attribute this upload to.",
77
+
"format": "at-identifier"
78
+
},
79
+
"blob": {
80
+
"type": "blob",
81
+
"description": "The uploaded blob reference. Note: Individual PDS instances may enforce lower size limits.",
82
+
"accept": [
83
+
"*/*"
84
+
],
85
+
"maxSize": 1000000000
86
+
},
87
+
"checksum": {
88
+
"type": "ref",
89
+
"description": "Optional cryptographic checksum for integrity verification.",
90
+
"ref": "#checksum"
91
+
},
92
+
"createdAt": {
93
+
"type": "string",
94
+
"description": "Timestamp when this record was created.",
95
+
"format": "datetime"
96
+
},
97
+
"file": {
98
+
"type": "ref",
99
+
"description": "Metadata about the file.",
100
+
"ref": "#file"
101
+
}
102
+
}
103
+
}
104
+
}
105
+
}
106
+
}
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_albums.rs
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_albums.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorAlbums
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorAlbums<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorAlbumsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.actor.getActorAlbums
51
+
pub struct GetActorAlbumsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetActorAlbumsResponse {
53
+
const NSID: &'static str = "app.rocksky.actor.getActorAlbums";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetActorAlbumsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorAlbums<'a> {
60
+
const NSID: &'static str = "app.rocksky.actor.getActorAlbums";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetActorAlbumsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.actor.getActorAlbums
67
+
pub struct GetActorAlbumsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorAlbumsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorAlbums";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetActorAlbums<'de>;
72
+
type Response = GetActorAlbumsResponse;
73
+
}
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_artists.rs
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_artists.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorArtists
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorArtists<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorArtistsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub artists: std::option::Option<
47
+
Vec<crate::app_rocksky::artist::ArtistViewBasic<'a>>,
48
+
>,
49
+
}
50
+
51
+
///Response type for
52
+
///app.rocksky.actor.getActorArtists
53
+
pub struct GetActorArtistsResponse;
54
+
impl jacquard_common::xrpc::XrpcResp for GetActorArtistsResponse {
55
+
const NSID: &'static str = "app.rocksky.actor.getActorArtists";
56
+
const ENCODING: &'static str = "application/json";
57
+
type Output<'de> = GetActorArtistsOutput<'de>;
58
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
59
+
}
60
+
61
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorArtists<'a> {
62
+
const NSID: &'static str = "app.rocksky.actor.getActorArtists";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Response = GetActorArtistsResponse;
65
+
}
66
+
67
+
///Endpoint type for
68
+
///app.rocksky.actor.getActorArtists
69
+
pub struct GetActorArtistsRequest;
70
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorArtistsRequest {
71
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorArtists";
72
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
73
+
type Request<'de> = GetActorArtists<'de>;
74
+
type Response = GetActorArtistsResponse;
75
+
}
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_loved_songs.rs
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_loved_songs.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorLovedSongs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorLovedSongs<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorLovedSongsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.actor.getActorLovedSongs
51
+
pub struct GetActorLovedSongsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetActorLovedSongsResponse {
53
+
const NSID: &'static str = "app.rocksky.actor.getActorLovedSongs";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetActorLovedSongsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorLovedSongs<'a> {
60
+
const NSID: &'static str = "app.rocksky.actor.getActorLovedSongs";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetActorLovedSongsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.actor.getActorLovedSongs
67
+
pub struct GetActorLovedSongsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorLovedSongsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorLovedSongs";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetActorLovedSongs<'de>;
72
+
type Response = GetActorLovedSongsResponse;
73
+
}
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_playlists.rs
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_playlists.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorPlaylists
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorPlaylists<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorPlaylistsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub playlists: std::option::Option<
47
+
Vec<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>,
48
+
>,
49
+
}
50
+
51
+
///Response type for
52
+
///app.rocksky.actor.getActorPlaylists
53
+
pub struct GetActorPlaylistsResponse;
54
+
impl jacquard_common::xrpc::XrpcResp for GetActorPlaylistsResponse {
55
+
const NSID: &'static str = "app.rocksky.actor.getActorPlaylists";
56
+
const ENCODING: &'static str = "application/json";
57
+
type Output<'de> = GetActorPlaylistsOutput<'de>;
58
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
59
+
}
60
+
61
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorPlaylists<'a> {
62
+
const NSID: &'static str = "app.rocksky.actor.getActorPlaylists";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Response = GetActorPlaylistsResponse;
65
+
}
66
+
67
+
///Endpoint type for
68
+
///app.rocksky.actor.getActorPlaylists
69
+
pub struct GetActorPlaylistsRequest;
70
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorPlaylistsRequest {
71
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorPlaylists";
72
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
73
+
type Request<'de> = GetActorPlaylists<'de>;
74
+
type Response = GetActorPlaylistsResponse;
75
+
}
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_scrobbles.rs
+75
crates/jacquard-api/src/app_rocksky/actor/get_actor_scrobbles.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorScrobbles
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorScrobbles<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorScrobblesOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub scrobbles: std::option::Option<
47
+
Vec<crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>>,
48
+
>,
49
+
}
50
+
51
+
///Response type for
52
+
///app.rocksky.actor.getActorScrobbles
53
+
pub struct GetActorScrobblesResponse;
54
+
impl jacquard_common::xrpc::XrpcResp for GetActorScrobblesResponse {
55
+
const NSID: &'static str = "app.rocksky.actor.getActorScrobbles";
56
+
const ENCODING: &'static str = "application/json";
57
+
type Output<'de> = GetActorScrobblesOutput<'de>;
58
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
59
+
}
60
+
61
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorScrobbles<'a> {
62
+
const NSID: &'static str = "app.rocksky.actor.getActorScrobbles";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Response = GetActorScrobblesResponse;
65
+
}
66
+
67
+
///Endpoint type for
68
+
///app.rocksky.actor.getActorScrobbles
69
+
pub struct GetActorScrobblesRequest;
70
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorScrobblesRequest {
71
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorScrobbles";
72
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
73
+
type Request<'de> = GetActorScrobbles<'de>;
74
+
type Response = GetActorScrobblesResponse;
75
+
}
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_songs.rs
+73
crates/jacquard-api/src/app_rocksky/actor/get_actor_songs.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getActorSongs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetActorSongs<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetActorSongsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub songs: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.actor.getActorSongs
51
+
pub struct GetActorSongsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetActorSongsResponse {
53
+
const NSID: &'static str = "app.rocksky.actor.getActorSongs";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetActorSongsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorSongs<'a> {
60
+
const NSID: &'static str = "app.rocksky.actor.getActorSongs";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetActorSongsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.actor.getActorSongs
67
+
pub struct GetActorSongsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetActorSongsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorSongs";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetActorSongs<'de>;
72
+
type Response = GetActorSongsResponse;
73
+
}
+67
crates/jacquard-api/src/app_rocksky/actor/get_profile.rs
+67
crates/jacquard-api/src/app_rocksky/actor/get_profile.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.getProfile
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetProfile<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetProfileOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::actor::ProfileViewDetailed<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.actor.getProfile
45
+
pub struct GetProfileResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetProfileResponse {
47
+
const NSID: &'static str = "app.rocksky.actor.getProfile";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetProfileOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetProfile<'a> {
54
+
const NSID: &'static str = "app.rocksky.actor.getProfile";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetProfileResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.actor.getProfile
61
+
pub struct GetProfileRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetProfileRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.actor.getProfile";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetProfile<'de>;
66
+
type Response = GetProfileResponse;
67
+
}
+96
crates/jacquard-api/src/app_rocksky/actor.rs
+96
crates/jacquard-api/src/app_rocksky/actor.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.actor.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_actor_albums;
9
+
pub mod get_actor_artists;
10
+
pub mod get_actor_loved_songs;
11
+
pub mod get_actor_playlists;
12
+
pub mod get_actor_scrobbles;
13
+
pub mod get_actor_songs;
14
+
pub mod get_profile;
15
+
16
+
#[jacquard_derive::lexicon]
17
+
#[derive(
18
+
serde::Serialize,
19
+
serde::Deserialize,
20
+
Debug,
21
+
Clone,
22
+
PartialEq,
23
+
Eq,
24
+
jacquard_derive::IntoStatic,
25
+
Default
26
+
)]
27
+
#[serde(rename_all = "camelCase")]
28
+
pub struct ProfileViewBasic<'a> {
29
+
/// The URL of the actor's avatar image.
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[serde(borrow)]
32
+
pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
33
+
/// The date and time when the actor was created.
34
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
35
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
36
+
/// The DID of the actor.
37
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
38
+
#[serde(borrow)]
39
+
pub did: std::option::Option<jacquard_common::CowStr<'a>>,
40
+
/// The display name of the actor.
41
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
42
+
#[serde(borrow)]
43
+
pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
44
+
/// The handle of the actor.
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub handle: std::option::Option<jacquard_common::CowStr<'a>>,
48
+
/// The unique identifier of the actor.
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[serde(borrow)]
51
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
52
+
/// The date and time when the actor was last updated.
53
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
54
+
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
55
+
}
56
+
57
+
#[jacquard_derive::lexicon]
58
+
#[derive(
59
+
serde::Serialize,
60
+
serde::Deserialize,
61
+
Debug,
62
+
Clone,
63
+
PartialEq,
64
+
Eq,
65
+
jacquard_derive::IntoStatic,
66
+
Default
67
+
)]
68
+
#[serde(rename_all = "camelCase")]
69
+
pub struct ProfileViewDetailed<'a> {
70
+
/// The URL of the actor's avatar image.
71
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
72
+
#[serde(borrow)]
73
+
pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
74
+
/// The date and time when the actor was created.
75
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
76
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
77
+
/// The DID of the actor.
78
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
79
+
#[serde(borrow)]
80
+
pub did: std::option::Option<jacquard_common::CowStr<'a>>,
81
+
/// The display name of the actor.
82
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
83
+
#[serde(borrow)]
84
+
pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
85
+
/// The handle of the actor.
86
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
87
+
#[serde(borrow)]
88
+
pub handle: std::option::Option<jacquard_common::CowStr<'a>>,
89
+
/// The unique identifier of the actor.
90
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
91
+
#[serde(borrow)]
92
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
93
+
/// The date and time when the actor was last updated.
94
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
95
+
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
96
+
}
+66
crates/jacquard-api/src/app_rocksky/album/get_album.rs
+66
crates/jacquard-api/src/app_rocksky/album/get_album.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.album.getAlbum
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetAlbum<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetAlbumOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::album::AlbumViewDetailed<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.album.getAlbum
44
+
pub struct GetAlbumResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetAlbumResponse {
46
+
const NSID: &'static str = "app.rocksky.album.getAlbum";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetAlbumOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbum<'a> {
53
+
const NSID: &'static str = "app.rocksky.album.getAlbum";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetAlbumResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.album.getAlbum
60
+
pub struct GetAlbumRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbum";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetAlbum<'de>;
65
+
type Response = GetAlbumResponse;
66
+
}
+67
crates/jacquard-api/src/app_rocksky/album/get_album_tracks.rs
+67
crates/jacquard-api/src/app_rocksky/album/get_album_tracks.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.album.getAlbumTracks
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetAlbumTracks<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic,
34
+
Default
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetAlbumTracksOutput<'a> {
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
#[serde(borrow)]
40
+
pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.album.getAlbumTracks
45
+
pub struct GetAlbumTracksResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetAlbumTracksResponse {
47
+
const NSID: &'static str = "app.rocksky.album.getAlbumTracks";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetAlbumTracksOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbumTracks<'a> {
54
+
const NSID: &'static str = "app.rocksky.album.getAlbumTracks";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetAlbumTracksResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.album.getAlbumTracks
61
+
pub struct GetAlbumTracksRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumTracksRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbumTracks";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetAlbumTracks<'de>;
66
+
type Response = GetAlbumTracksResponse;
67
+
}
+71
crates/jacquard-api/src/app_rocksky/album/get_albums.rs
+71
crates/jacquard-api/src/app_rocksky/album/get_albums.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.album.getAlbums
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetAlbums {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
}
28
+
29
+
#[jacquard_derive::lexicon]
30
+
#[derive(
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
Debug,
34
+
Clone,
35
+
PartialEq,
36
+
Eq,
37
+
jacquard_derive::IntoStatic,
38
+
Default
39
+
)]
40
+
#[serde(rename_all = "camelCase")]
41
+
pub struct GetAlbumsOutput<'a> {
42
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
43
+
#[serde(borrow)]
44
+
pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,
45
+
}
46
+
47
+
///Response type for
48
+
///app.rocksky.album.getAlbums
49
+
pub struct GetAlbumsResponse;
50
+
impl jacquard_common::xrpc::XrpcResp for GetAlbumsResponse {
51
+
const NSID: &'static str = "app.rocksky.album.getAlbums";
52
+
const ENCODING: &'static str = "application/json";
53
+
type Output<'de> = GetAlbumsOutput<'de>;
54
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
55
+
}
56
+
57
+
impl jacquard_common::xrpc::XrpcRequest for GetAlbums {
58
+
const NSID: &'static str = "app.rocksky.album.getAlbums";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
60
+
type Response = GetAlbumsResponse;
61
+
}
62
+
63
+
///Endpoint type for
64
+
///app.rocksky.album.getAlbums
65
+
pub struct GetAlbumsRequest;
66
+
impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumsRequest {
67
+
const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbums";
68
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
69
+
type Request<'de> = GetAlbums;
70
+
type Response = GetAlbumsResponse;
71
+
}
+240
crates/jacquard-api/src/app_rocksky/album.rs
+240
crates/jacquard-api/src/app_rocksky/album.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.album.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_album;
9
+
pub mod get_album_tracks;
10
+
pub mod get_albums;
11
+
12
+
/// A declaration of an album.
13
+
#[jacquard_derive::lexicon]
14
+
#[derive(
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
Debug,
18
+
Clone,
19
+
PartialEq,
20
+
Eq,
21
+
jacquard_derive::IntoStatic,
22
+
bon::Builder
23
+
)]
24
+
#[serde(rename_all = "camelCase")]
25
+
pub struct Album<'a> {
26
+
/// The album art of the album.
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
#[builder(into)]
29
+
#[serde(borrow)]
30
+
pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,
31
+
/// The Apple Music link of the album.
32
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
33
+
#[builder(into)]
34
+
#[serde(borrow)]
35
+
pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,
36
+
/// The artist of the album.
37
+
#[serde(borrow)]
38
+
#[builder(into)]
39
+
pub artist: jacquard_common::CowStr<'a>,
40
+
/// The date and time when the album was created.
41
+
pub created_at: jacquard_common::types::string::Datetime,
42
+
/// The duration of the album in seconds.
43
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
44
+
#[builder(into)]
45
+
pub duration: Option<i64>,
46
+
/// The genre of the album.
47
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
48
+
#[builder(into)]
49
+
#[serde(borrow)]
50
+
pub genre: Option<jacquard_common::CowStr<'a>>,
51
+
/// The release date of the album.
52
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
53
+
#[builder(into)]
54
+
pub release_date: Option<jacquard_common::types::string::Datetime>,
55
+
/// The Spotify link of the album.
56
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
57
+
#[builder(into)]
58
+
#[serde(borrow)]
59
+
pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,
60
+
/// The tags of the album.
61
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
62
+
#[builder(into)]
63
+
#[serde(borrow)]
64
+
pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
65
+
/// The tidal link of the album.
66
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
67
+
#[builder(into)]
68
+
#[serde(borrow)]
69
+
pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,
70
+
/// The title of the album.
71
+
#[serde(borrow)]
72
+
#[builder(into)]
73
+
pub title: jacquard_common::CowStr<'a>,
74
+
/// The year the album was released.
75
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
76
+
#[builder(into)]
77
+
pub year: Option<i64>,
78
+
/// The YouTube link of the album.
79
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
80
+
#[builder(into)]
81
+
#[serde(borrow)]
82
+
pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,
83
+
}
84
+
85
+
/// Typed wrapper for GetRecord response with this collection's record type.
86
+
#[derive(
87
+
serde::Serialize,
88
+
serde::Deserialize,
89
+
Debug,
90
+
Clone,
91
+
PartialEq,
92
+
Eq,
93
+
jacquard_derive::IntoStatic
94
+
)]
95
+
#[serde(rename_all = "camelCase")]
96
+
pub struct AlbumGetRecordOutput<'a> {
97
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
98
+
#[serde(borrow)]
99
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
100
+
#[serde(borrow)]
101
+
pub uri: jacquard_common::types::string::AtUri<'a>,
102
+
#[serde(borrow)]
103
+
pub value: Album<'a>,
104
+
}
105
+
106
+
/// Marker type for deserializing records from this collection.
107
+
pub struct AlbumRecord;
108
+
impl jacquard_common::xrpc::XrpcResp for AlbumRecord {
109
+
const NSID: &'static str = "app.rocksky.album";
110
+
const ENCODING: &'static str = "application/json";
111
+
type Output<'de> = AlbumGetRecordOutput<'de>;
112
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
113
+
}
114
+
115
+
impl jacquard_common::types::collection::Collection for Album<'_> {
116
+
const NSID: &'static str = "app.rocksky.album";
117
+
type Record = AlbumRecord;
118
+
}
119
+
120
+
impl From<AlbumGetRecordOutput<'_>> for Album<'_> {
121
+
fn from(output: AlbumGetRecordOutput<'_>) -> Self {
122
+
use jacquard_common::IntoStatic;
123
+
output.value.into_static()
124
+
}
125
+
}
126
+
127
+
#[jacquard_derive::lexicon]
128
+
#[derive(
129
+
serde::Serialize,
130
+
serde::Deserialize,
131
+
Debug,
132
+
Clone,
133
+
PartialEq,
134
+
Eq,
135
+
jacquard_derive::IntoStatic,
136
+
Default
137
+
)]
138
+
#[serde(rename_all = "camelCase")]
139
+
pub struct AlbumViewBasic<'a> {
140
+
/// The URL of the album art image.
141
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
142
+
#[serde(borrow)]
143
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
144
+
/// The artist of the album.
145
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
146
+
#[serde(borrow)]
147
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
148
+
/// The URI of the album's artist.
149
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
150
+
#[serde(borrow)]
151
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
152
+
/// The unique identifier of the album.
153
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
154
+
#[serde(borrow)]
155
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
156
+
/// The number of times the album has been played.
157
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
158
+
pub play_count: std::option::Option<i64>,
159
+
/// The release date of the album.
160
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
161
+
#[serde(borrow)]
162
+
pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,
163
+
/// The SHA256 hash of the album.
164
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
165
+
#[serde(borrow)]
166
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
167
+
/// The title of the album.
168
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
169
+
#[serde(borrow)]
170
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
171
+
/// The number of unique listeners who have played the album.
172
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
173
+
pub unique_listeners: std::option::Option<i64>,
174
+
/// The URI of the album.
175
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
176
+
#[serde(borrow)]
177
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
178
+
/// The year the album was released.
179
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
180
+
pub year: std::option::Option<i64>,
181
+
}
182
+
183
+
#[jacquard_derive::lexicon]
184
+
#[derive(
185
+
serde::Serialize,
186
+
serde::Deserialize,
187
+
Debug,
188
+
Clone,
189
+
PartialEq,
190
+
Eq,
191
+
jacquard_derive::IntoStatic,
192
+
Default
193
+
)]
194
+
#[serde(rename_all = "camelCase")]
195
+
pub struct AlbumViewDetailed<'a> {
196
+
/// The URL of the album art image.
197
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
198
+
#[serde(borrow)]
199
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
200
+
/// The artist of the album.
201
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
202
+
#[serde(borrow)]
203
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
204
+
/// The URI of the album's artist.
205
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
206
+
#[serde(borrow)]
207
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
208
+
/// The unique identifier of the album.
209
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
210
+
#[serde(borrow)]
211
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
212
+
/// The number of times the album has been played.
213
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
214
+
pub play_count: std::option::Option<i64>,
215
+
/// The release date of the album.
216
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
217
+
#[serde(borrow)]
218
+
pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,
219
+
/// The SHA256 hash of the album.
220
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
221
+
#[serde(borrow)]
222
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
223
+
/// The title of the album.
224
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
225
+
#[serde(borrow)]
226
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
227
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
228
+
#[serde(borrow)]
229
+
pub tracks: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
230
+
/// The number of unique listeners who have played the album.
231
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
232
+
pub unique_listeners: std::option::Option<i64>,
233
+
/// The URI of the album.
234
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
235
+
#[serde(borrow)]
236
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
237
+
/// The year the album was released.
238
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
239
+
pub year: std::option::Option<i64>,
240
+
}
+75
crates/jacquard-api/src/app_rocksky/apikey/create_apikey.rs
+75
crates/jacquard-api/src/app_rocksky/apikey/create_apikey.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.apikey.createApikey
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct CreateApikey<'a> {
21
+
/// A description for the API key.
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
/// The name of the API key.
26
+
#[serde(borrow)]
27
+
pub name: jacquard_common::CowStr<'a>,
28
+
}
29
+
30
+
#[jacquard_derive::lexicon]
31
+
#[derive(
32
+
serde::Serialize,
33
+
serde::Deserialize,
34
+
Debug,
35
+
Clone,
36
+
PartialEq,
37
+
Eq,
38
+
jacquard_derive::IntoStatic
39
+
)]
40
+
#[serde(rename_all = "camelCase")]
41
+
pub struct CreateApikeyOutput<'a> {
42
+
#[serde(flatten)]
43
+
#[serde(borrow)]
44
+
pub value: jacquard_common::types::value::Data<'a>,
45
+
}
46
+
47
+
///Response type for
48
+
///app.rocksky.apikey.createApikey
49
+
pub struct CreateApikeyResponse;
50
+
impl jacquard_common::xrpc::XrpcResp for CreateApikeyResponse {
51
+
const NSID: &'static str = "app.rocksky.apikey.createApikey";
52
+
const ENCODING: &'static str = "application/json";
53
+
type Output<'de> = CreateApikeyOutput<'de>;
54
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
55
+
}
56
+
57
+
impl<'a> jacquard_common::xrpc::XrpcRequest for CreateApikey<'a> {
58
+
const NSID: &'static str = "app.rocksky.apikey.createApikey";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
60
+
"application/json",
61
+
);
62
+
type Response = CreateApikeyResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.apikey.createApikey
67
+
pub struct CreateApikeyRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for CreateApikeyRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.apikey.createApikey";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
71
+
"application/json",
72
+
);
73
+
type Request<'de> = CreateApikey<'de>;
74
+
type Response = CreateApikeyResponse;
75
+
}
+69
crates/jacquard-api/src/app_rocksky/apikey/get_apikeys.rs
+69
crates/jacquard-api/src/app_rocksky/apikey/get_apikeys.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.apikey.getApikeys
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetApikeys {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
pub limit: std::option::Option<i64>,
23
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
24
+
pub offset: std::option::Option<i64>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic,
36
+
Default
37
+
)]
38
+
#[serde(rename_all = "camelCase")]
39
+
pub struct GetApikeysOutput<'a> {
40
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
41
+
#[serde(borrow)]
42
+
pub api_keys: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
43
+
}
44
+
45
+
///Response type for
46
+
///app.rocksky.apikey.getApikeys
47
+
pub struct GetApikeysResponse;
48
+
impl jacquard_common::xrpc::XrpcResp for GetApikeysResponse {
49
+
const NSID: &'static str = "app.rocksky.apikey.getApikeys";
50
+
const ENCODING: &'static str = "application/json";
51
+
type Output<'de> = GetApikeysOutput<'de>;
52
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
53
+
}
54
+
55
+
impl jacquard_common::xrpc::XrpcRequest for GetApikeys {
56
+
const NSID: &'static str = "app.rocksky.apikey.getApikeys";
57
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
58
+
type Response = GetApikeysResponse;
59
+
}
60
+
61
+
///Endpoint type for
62
+
///app.rocksky.apikey.getApikeys
63
+
pub struct GetApikeysRequest;
64
+
impl jacquard_common::xrpc::XrpcEndpoint for GetApikeysRequest {
65
+
const PATH: &'static str = "/xrpc/app.rocksky.apikey.getApikeys";
66
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
67
+
type Request<'de> = GetApikeys;
68
+
type Response = GetApikeysResponse;
69
+
}
+83
crates/jacquard-api/src/app_rocksky/apikey/remove_apikey.rs
+83
crates/jacquard-api/src/app_rocksky/apikey/remove_apikey.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.apikey.removeApikey
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct RemoveApikeyParams<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub id: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct RemoveApikeyOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: jacquard_common::types::value::Data<'a>,
41
+
}
42
+
43
+
/// XRPC request marker type
44
+
#[derive(
45
+
Debug,
46
+
Clone,
47
+
Copy,
48
+
PartialEq,
49
+
Eq,
50
+
serde::Serialize,
51
+
serde::Deserialize,
52
+
jacquard_derive::IntoStatic
53
+
)]
54
+
pub struct RemoveApikey;
55
+
///Response type for
56
+
///app.rocksky.apikey.removeApikey
57
+
pub struct RemoveApikeyResponse;
58
+
impl jacquard_common::xrpc::XrpcResp for RemoveApikeyResponse {
59
+
const NSID: &'static str = "app.rocksky.apikey.removeApikey";
60
+
const ENCODING: &'static str = "application/json";
61
+
type Output<'de> = RemoveApikeyOutput<'de>;
62
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
63
+
}
64
+
65
+
impl jacquard_common::xrpc::XrpcRequest for RemoveApikey {
66
+
const NSID: &'static str = "app.rocksky.apikey.removeApikey";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Response = RemoveApikeyResponse;
71
+
}
72
+
73
+
///Endpoint type for
74
+
///app.rocksky.apikey.removeApikey
75
+
pub struct RemoveApikeyRequest;
76
+
impl jacquard_common::xrpc::XrpcEndpoint for RemoveApikeyRequest {
77
+
const PATH: &'static str = "/xrpc/app.rocksky.apikey.removeApikey";
78
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
79
+
"application/json",
80
+
);
81
+
type Request<'de> = RemoveApikey;
82
+
type Response = RemoveApikeyResponse;
83
+
}
+78
crates/jacquard-api/src/app_rocksky/apikey/update_apikey.rs
+78
crates/jacquard-api/src/app_rocksky/apikey/update_apikey.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.apikey.updateApikey
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct UpdateApikey<'a> {
21
+
/// A new description for the API key.
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
/// The ID of the API key to update.
26
+
#[serde(borrow)]
27
+
pub id: jacquard_common::CowStr<'a>,
28
+
/// The new name of the API key.
29
+
#[serde(borrow)]
30
+
pub name: jacquard_common::CowStr<'a>,
31
+
}
32
+
33
+
#[jacquard_derive::lexicon]
34
+
#[derive(
35
+
serde::Serialize,
36
+
serde::Deserialize,
37
+
Debug,
38
+
Clone,
39
+
PartialEq,
40
+
Eq,
41
+
jacquard_derive::IntoStatic
42
+
)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct UpdateApikeyOutput<'a> {
45
+
#[serde(flatten)]
46
+
#[serde(borrow)]
47
+
pub value: jacquard_common::types::value::Data<'a>,
48
+
}
49
+
50
+
///Response type for
51
+
///app.rocksky.apikey.updateApikey
52
+
pub struct UpdateApikeyResponse;
53
+
impl jacquard_common::xrpc::XrpcResp for UpdateApikeyResponse {
54
+
const NSID: &'static str = "app.rocksky.apikey.updateApikey";
55
+
const ENCODING: &'static str = "application/json";
56
+
type Output<'de> = UpdateApikeyOutput<'de>;
57
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
58
+
}
59
+
60
+
impl<'a> jacquard_common::xrpc::XrpcRequest for UpdateApikey<'a> {
61
+
const NSID: &'static str = "app.rocksky.apikey.updateApikey";
62
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
63
+
"application/json",
64
+
);
65
+
type Response = UpdateApikeyResponse;
66
+
}
67
+
68
+
///Endpoint type for
69
+
///app.rocksky.apikey.updateApikey
70
+
pub struct UpdateApikeyRequest;
71
+
impl jacquard_common::xrpc::XrpcEndpoint for UpdateApikeyRequest {
72
+
const PATH: &'static str = "/xrpc/app.rocksky.apikey.updateApikey";
73
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
74
+
"application/json",
75
+
);
76
+
type Request<'de> = UpdateApikey<'de>;
77
+
type Response = UpdateApikeyResponse;
78
+
}
+41
crates/jacquard-api/src/app_rocksky/apikey.rs
+41
crates/jacquard-api/src/app_rocksky/apikey.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.apikey.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod create_apikey;
9
+
pub mod get_apikeys;
10
+
pub mod remove_apikey;
11
+
pub mod update_apikey;
12
+
13
+
#[jacquard_derive::lexicon]
14
+
#[derive(
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
Debug,
18
+
Clone,
19
+
PartialEq,
20
+
Eq,
21
+
jacquard_derive::IntoStatic,
22
+
Default
23
+
)]
24
+
#[serde(rename_all = "camelCase")]
25
+
pub struct ApiKeyView<'a> {
26
+
/// The date and time when the API key was created.
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
29
+
/// A description for the API key.
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[serde(borrow)]
32
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
33
+
/// The unique identifier of the API key.
34
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
35
+
#[serde(borrow)]
36
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
37
+
/// The name of the API key.
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
#[serde(borrow)]
40
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
41
+
}
+66
crates/jacquard-api/src/app_rocksky/artist/get_artist.rs
+66
crates/jacquard-api/src/app_rocksky/artist/get_artist.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.artist.getArtist
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetArtist<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetArtistOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::artist::ArtistViewDetailed<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.artist.getArtist
44
+
pub struct GetArtistResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetArtistResponse {
46
+
const NSID: &'static str = "app.rocksky.artist.getArtist";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetArtistOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtist<'a> {
53
+
const NSID: &'static str = "app.rocksky.artist.getArtist";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetArtistResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.artist.getArtist
60
+
pub struct GetArtistRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetArtistRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtist";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetArtist<'de>;
65
+
type Response = GetArtistResponse;
66
+
}
+67
crates/jacquard-api/src/app_rocksky/artist/get_artist_albums.rs
+67
crates/jacquard-api/src/app_rocksky/artist/get_artist_albums.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.artist.getArtistAlbums
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetArtistAlbums<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic,
34
+
Default
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetArtistAlbumsOutput<'a> {
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
#[serde(borrow)]
40
+
pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.artist.getArtistAlbums
45
+
pub struct GetArtistAlbumsResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetArtistAlbumsResponse {
47
+
const NSID: &'static str = "app.rocksky.artist.getArtistAlbums";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetArtistAlbumsOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistAlbums<'a> {
54
+
const NSID: &'static str = "app.rocksky.artist.getArtistAlbums";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetArtistAlbumsResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.artist.getArtistAlbums
61
+
pub struct GetArtistAlbumsRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetArtistAlbumsRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtistAlbums";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetArtistAlbums<'de>;
66
+
type Response = GetArtistAlbumsResponse;
67
+
}
+74
crates/jacquard-api/src/app_rocksky/artist/get_artist_tracks.rs
+74
crates/jacquard-api/src/app_rocksky/artist/get_artist_tracks.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.artist.getArtistTracks
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetArtistTracks<'a> {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
#[serde(borrow)]
29
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
30
+
}
31
+
32
+
#[jacquard_derive::lexicon]
33
+
#[derive(
34
+
serde::Serialize,
35
+
serde::Deserialize,
36
+
Debug,
37
+
Clone,
38
+
PartialEq,
39
+
Eq,
40
+
jacquard_derive::IntoStatic,
41
+
Default
42
+
)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct GetArtistTracksOutput<'a> {
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
48
+
}
49
+
50
+
///Response type for
51
+
///app.rocksky.artist.getArtistTracks
52
+
pub struct GetArtistTracksResponse;
53
+
impl jacquard_common::xrpc::XrpcResp for GetArtistTracksResponse {
54
+
const NSID: &'static str = "app.rocksky.artist.getArtistTracks";
55
+
const ENCODING: &'static str = "application/json";
56
+
type Output<'de> = GetArtistTracksOutput<'de>;
57
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
58
+
}
59
+
60
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistTracks<'a> {
61
+
const NSID: &'static str = "app.rocksky.artist.getArtistTracks";
62
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
63
+
type Response = GetArtistTracksResponse;
64
+
}
65
+
66
+
///Endpoint type for
67
+
///app.rocksky.artist.getArtistTracks
68
+
pub struct GetArtistTracksRequest;
69
+
impl jacquard_common::xrpc::XrpcEndpoint for GetArtistTracksRequest {
70
+
const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtistTracks";
71
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
72
+
type Request<'de> = GetArtistTracks<'de>;
73
+
type Response = GetArtistTracksResponse;
74
+
}
+73
crates/jacquard-api/src/app_rocksky/artist/get_artists.rs
+73
crates/jacquard-api/src/app_rocksky/artist/get_artists.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.artist.getArtists
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetArtists {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
}
28
+
29
+
#[jacquard_derive::lexicon]
30
+
#[derive(
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
Debug,
34
+
Clone,
35
+
PartialEq,
36
+
Eq,
37
+
jacquard_derive::IntoStatic,
38
+
Default
39
+
)]
40
+
#[serde(rename_all = "camelCase")]
41
+
pub struct GetArtistsOutput<'a> {
42
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
43
+
#[serde(borrow)]
44
+
pub artists: std::option::Option<
45
+
Vec<crate::app_rocksky::artist::ArtistViewBasic<'a>>,
46
+
>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.artist.getArtists
51
+
pub struct GetArtistsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetArtistsResponse {
53
+
const NSID: &'static str = "app.rocksky.artist.getArtists";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetArtistsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl jacquard_common::xrpc::XrpcRequest for GetArtists {
60
+
const NSID: &'static str = "app.rocksky.artist.getArtists";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetArtistsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.artist.getArtists
67
+
pub struct GetArtistsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetArtistsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtists";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetArtists;
72
+
type Response = GetArtistsResponse;
73
+
}
+185
crates/jacquard-api/src/app_rocksky/artist.rs
+185
crates/jacquard-api/src/app_rocksky/artist.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.artist.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_artist;
9
+
pub mod get_artist_albums;
10
+
pub mod get_artist_tracks;
11
+
pub mod get_artists;
12
+
13
+
/// A declaration of an artist.
14
+
#[jacquard_derive::lexicon]
15
+
#[derive(
16
+
serde::Serialize,
17
+
serde::Deserialize,
18
+
Debug,
19
+
Clone,
20
+
PartialEq,
21
+
Eq,
22
+
jacquard_derive::IntoStatic,
23
+
bon::Builder
24
+
)]
25
+
#[serde(rename_all = "camelCase")]
26
+
pub struct Artist<'a> {
27
+
/// The biography of the artist.
28
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
29
+
#[builder(into)]
30
+
#[serde(borrow)]
31
+
pub bio: Option<jacquard_common::CowStr<'a>>,
32
+
/// The birth date of the artist.
33
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
34
+
#[builder(into)]
35
+
pub born: Option<jacquard_common::types::string::Datetime>,
36
+
/// The birth place of the artist.
37
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
38
+
#[builder(into)]
39
+
#[serde(borrow)]
40
+
pub born_in: Option<jacquard_common::CowStr<'a>>,
41
+
/// The date when the artist was created.
42
+
pub created_at: jacquard_common::types::string::Datetime,
43
+
/// The death date of the artist.
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[builder(into)]
46
+
pub died: Option<jacquard_common::types::string::Datetime>,
47
+
/// The name of the artist.
48
+
#[serde(borrow)]
49
+
#[builder(into)]
50
+
pub name: jacquard_common::CowStr<'a>,
51
+
/// The picture of the artist.
52
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
53
+
#[builder(into)]
54
+
#[serde(borrow)]
55
+
pub picture: Option<jacquard_common::types::blob::Blob<'a>>,
56
+
/// The tags of the artist.
57
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
+
#[builder(into)]
59
+
#[serde(borrow)]
60
+
pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
61
+
}
62
+
63
+
/// Typed wrapper for GetRecord response with this collection's record type.
64
+
#[derive(
65
+
serde::Serialize,
66
+
serde::Deserialize,
67
+
Debug,
68
+
Clone,
69
+
PartialEq,
70
+
Eq,
71
+
jacquard_derive::IntoStatic
72
+
)]
73
+
#[serde(rename_all = "camelCase")]
74
+
pub struct ArtistGetRecordOutput<'a> {
75
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
76
+
#[serde(borrow)]
77
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
78
+
#[serde(borrow)]
79
+
pub uri: jacquard_common::types::string::AtUri<'a>,
80
+
#[serde(borrow)]
81
+
pub value: Artist<'a>,
82
+
}
83
+
84
+
/// Marker type for deserializing records from this collection.
85
+
pub struct ArtistRecord;
86
+
impl jacquard_common::xrpc::XrpcResp for ArtistRecord {
87
+
const NSID: &'static str = "app.rocksky.artist";
88
+
const ENCODING: &'static str = "application/json";
89
+
type Output<'de> = ArtistGetRecordOutput<'de>;
90
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
91
+
}
92
+
93
+
impl jacquard_common::types::collection::Collection for Artist<'_> {
94
+
const NSID: &'static str = "app.rocksky.artist";
95
+
type Record = ArtistRecord;
96
+
}
97
+
98
+
impl From<ArtistGetRecordOutput<'_>> for Artist<'_> {
99
+
fn from(output: ArtistGetRecordOutput<'_>) -> Self {
100
+
use jacquard_common::IntoStatic;
101
+
output.value.into_static()
102
+
}
103
+
}
104
+
105
+
#[jacquard_derive::lexicon]
106
+
#[derive(
107
+
serde::Serialize,
108
+
serde::Deserialize,
109
+
Debug,
110
+
Clone,
111
+
PartialEq,
112
+
Eq,
113
+
jacquard_derive::IntoStatic,
114
+
Default
115
+
)]
116
+
#[serde(rename_all = "camelCase")]
117
+
pub struct ArtistViewBasic<'a> {
118
+
/// The unique identifier of the artist.
119
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
120
+
#[serde(borrow)]
121
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
122
+
/// The name of the artist.
123
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
124
+
#[serde(borrow)]
125
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
126
+
/// The picture of the artist.
127
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
128
+
#[serde(borrow)]
129
+
pub picture: std::option::Option<jacquard_common::CowStr<'a>>,
130
+
/// The number of times the artist has been played.
131
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
132
+
pub play_count: std::option::Option<i64>,
133
+
/// The SHA256 hash of the artist.
134
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
135
+
#[serde(borrow)]
136
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
137
+
/// The number of unique listeners who have played the artist.
138
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
139
+
pub unique_listeners: std::option::Option<i64>,
140
+
/// The URI of the artist.
141
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
142
+
#[serde(borrow)]
143
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
144
+
}
145
+
146
+
#[jacquard_derive::lexicon]
147
+
#[derive(
148
+
serde::Serialize,
149
+
serde::Deserialize,
150
+
Debug,
151
+
Clone,
152
+
PartialEq,
153
+
Eq,
154
+
jacquard_derive::IntoStatic,
155
+
Default
156
+
)]
157
+
#[serde(rename_all = "camelCase")]
158
+
pub struct ArtistViewDetailed<'a> {
159
+
/// The unique identifier of the artist.
160
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
161
+
#[serde(borrow)]
162
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
163
+
/// The name of the artist.
164
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
165
+
#[serde(borrow)]
166
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
167
+
/// The picture of the artist.
168
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
169
+
#[serde(borrow)]
170
+
pub picture: std::option::Option<jacquard_common::CowStr<'a>>,
171
+
/// The number of times the artist has been played.
172
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
173
+
pub play_count: std::option::Option<i64>,
174
+
/// The SHA256 hash of the artist.
175
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
176
+
#[serde(borrow)]
177
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
178
+
/// The number of unique listeners who have played the artist.
179
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
180
+
pub unique_listeners: std::option::Option<i64>,
181
+
/// The URI of the artist.
182
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
183
+
#[serde(borrow)]
184
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
185
+
}
+76
crates/jacquard-api/src/app_rocksky/charts/get_scrobbles_chart.rs
+76
crates/jacquard-api/src/app_rocksky/charts/get_scrobbles_chart.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.charts.getScrobblesChart
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetScrobblesChart<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
pub albumuri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
#[serde(borrow)]
26
+
pub artisturi: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
#[serde(borrow)]
29
+
pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[serde(borrow)]
32
+
pub songuri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
33
+
}
34
+
35
+
#[jacquard_derive::lexicon]
36
+
#[derive(
37
+
serde::Serialize,
38
+
serde::Deserialize,
39
+
Debug,
40
+
Clone,
41
+
PartialEq,
42
+
Eq,
43
+
jacquard_derive::IntoStatic
44
+
)]
45
+
#[serde(rename_all = "camelCase")]
46
+
pub struct GetScrobblesChartOutput<'a> {
47
+
#[serde(flatten)]
48
+
#[serde(borrow)]
49
+
pub value: crate::app_rocksky::charts::ChartsView<'a>,
50
+
}
51
+
52
+
///Response type for
53
+
///app.rocksky.charts.getScrobblesChart
54
+
pub struct GetScrobblesChartResponse;
55
+
impl jacquard_common::xrpc::XrpcResp for GetScrobblesChartResponse {
56
+
const NSID: &'static str = "app.rocksky.charts.getScrobblesChart";
57
+
const ENCODING: &'static str = "application/json";
58
+
type Output<'de> = GetScrobblesChartOutput<'de>;
59
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
60
+
}
61
+
62
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobblesChart<'a> {
63
+
const NSID: &'static str = "app.rocksky.charts.getScrobblesChart";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Response = GetScrobblesChartResponse;
66
+
}
67
+
68
+
///Endpoint type for
69
+
///app.rocksky.charts.getScrobblesChart
70
+
pub struct GetScrobblesChartRequest;
71
+
impl jacquard_common::xrpc::XrpcEndpoint for GetScrobblesChartRequest {
72
+
const PATH: &'static str = "/xrpc/app.rocksky.charts.getScrobblesChart";
73
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
74
+
type Request<'de> = GetScrobblesChart<'de>;
75
+
type Response = GetScrobblesChartResponse;
76
+
}
+49
crates/jacquard-api/src/app_rocksky/charts.rs
+49
crates/jacquard-api/src/app_rocksky/charts.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.charts.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_scrobbles_chart;
9
+
10
+
#[jacquard_derive::lexicon]
11
+
#[derive(
12
+
serde::Serialize,
13
+
serde::Deserialize,
14
+
Debug,
15
+
Clone,
16
+
PartialEq,
17
+
Eq,
18
+
jacquard_derive::IntoStatic,
19
+
Default
20
+
)]
21
+
#[serde(rename_all = "camelCase")]
22
+
pub struct ChartsView<'a> {
23
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
24
+
#[serde(borrow)]
25
+
pub scrobbles: std::option::Option<
26
+
Vec<crate::app_rocksky::charts::ScrobbleViewBasic<'a>>,
27
+
>,
28
+
}
29
+
30
+
#[jacquard_derive::lexicon]
31
+
#[derive(
32
+
serde::Serialize,
33
+
serde::Deserialize,
34
+
Debug,
35
+
Clone,
36
+
PartialEq,
37
+
Eq,
38
+
jacquard_derive::IntoStatic,
39
+
Default
40
+
)]
41
+
#[serde(rename_all = "camelCase")]
42
+
pub struct ScrobbleViewBasic<'a> {
43
+
/// The number of scrobbles on this date.
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
pub count: std::option::Option<i64>,
46
+
/// The date of the scrobble.
47
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
48
+
pub date: std::option::Option<jacquard_common::types::string::Datetime>,
49
+
}
+62
crates/jacquard-api/src/app_rocksky/dropbox/download_file.rs
+62
crates/jacquard-api/src/app_rocksky/dropbox/download_file.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.dropbox.downloadFile
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct DownloadFile<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub file_id: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct DownloadFileOutput<'a> {}
38
+
///Response type for
39
+
///app.rocksky.dropbox.downloadFile
40
+
pub struct DownloadFileResponse;
41
+
impl jacquard_common::xrpc::XrpcResp for DownloadFileResponse {
42
+
const NSID: &'static str = "app.rocksky.dropbox.downloadFile";
43
+
const ENCODING: &'static str = "application/octet-stream";
44
+
type Output<'de> = DownloadFileOutput<'de>;
45
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
46
+
}
47
+
48
+
impl<'a> jacquard_common::xrpc::XrpcRequest for DownloadFile<'a> {
49
+
const NSID: &'static str = "app.rocksky.dropbox.downloadFile";
50
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
51
+
type Response = DownloadFileResponse;
52
+
}
53
+
54
+
///Endpoint type for
55
+
///app.rocksky.dropbox.downloadFile
56
+
pub struct DownloadFileRequest;
57
+
impl jacquard_common::xrpc::XrpcEndpoint for DownloadFileRequest {
58
+
const PATH: &'static str = "/xrpc/app.rocksky.dropbox.downloadFile";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
60
+
type Request<'de> = DownloadFile<'de>;
61
+
type Response = DownloadFileResponse;
62
+
}
+68
crates/jacquard-api/src/app_rocksky/dropbox/get_files.rs
+68
crates/jacquard-api/src/app_rocksky/dropbox/get_files.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.dropbox.getFiles
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetFiles<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
#[builder(into)]
24
+
pub at: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct GetFilesOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::dropbox::FileListView<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.dropbox.getFiles
46
+
pub struct GetFilesResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for GetFilesResponse {
48
+
const NSID: &'static str = "app.rocksky.dropbox.getFiles";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = GetFilesOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetFiles<'a> {
55
+
const NSID: &'static str = "app.rocksky.dropbox.getFiles";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
57
+
type Response = GetFilesResponse;
58
+
}
59
+
60
+
///Endpoint type for
61
+
///app.rocksky.dropbox.getFiles
62
+
pub struct GetFilesRequest;
63
+
impl jacquard_common::xrpc::XrpcEndpoint for GetFilesRequest {
64
+
const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getFiles";
65
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
66
+
type Request<'de> = GetFiles<'de>;
67
+
type Response = GetFilesResponse;
68
+
}
+67
crates/jacquard-api/src/app_rocksky/dropbox/get_metadata.rs
+67
crates/jacquard-api/src/app_rocksky/dropbox/get_metadata.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.dropbox.getMetadata
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetMetadata<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub path: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetMetadataOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::dropbox::FileView<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.dropbox.getMetadata
45
+
pub struct GetMetadataResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetMetadataResponse {
47
+
const NSID: &'static str = "app.rocksky.dropbox.getMetadata";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetMetadataOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetMetadata<'a> {
54
+
const NSID: &'static str = "app.rocksky.dropbox.getMetadata";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetMetadataResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.dropbox.getMetadata
61
+
pub struct GetMetadataRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetMetadataRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getMetadata";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetMetadata<'de>;
66
+
type Response = GetMetadataResponse;
67
+
}
+67
crates/jacquard-api/src/app_rocksky/dropbox/get_temporary_link.rs
+67
crates/jacquard-api/src/app_rocksky/dropbox/get_temporary_link.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.dropbox.getTemporaryLink
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetTemporaryLink<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub path: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetTemporaryLinkOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::dropbox::TemporaryLinkView<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.dropbox.getTemporaryLink
45
+
pub struct GetTemporaryLinkResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetTemporaryLinkResponse {
47
+
const NSID: &'static str = "app.rocksky.dropbox.getTemporaryLink";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetTemporaryLinkOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetTemporaryLink<'a> {
54
+
const NSID: &'static str = "app.rocksky.dropbox.getTemporaryLink";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetTemporaryLinkResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.dropbox.getTemporaryLink
61
+
pub struct GetTemporaryLinkRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetTemporaryLinkRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getTemporaryLink";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetTemporaryLink<'de>;
66
+
type Response = GetTemporaryLinkResponse;
67
+
}
+86
crates/jacquard-api/src/app_rocksky/dropbox.rs
+86
crates/jacquard-api/src/app_rocksky/dropbox.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.dropbox.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod download_file;
9
+
pub mod get_files;
10
+
pub mod get_metadata;
11
+
pub mod get_temporary_link;
12
+
13
+
#[jacquard_derive::lexicon]
14
+
#[derive(
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
Debug,
18
+
Clone,
19
+
PartialEq,
20
+
Eq,
21
+
jacquard_derive::IntoStatic,
22
+
Default
23
+
)]
24
+
#[serde(rename_all = "camelCase")]
25
+
pub struct FileListView<'a> {
26
+
/// A list of files in the Dropbox.
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
#[serde(borrow)]
29
+
pub files: std::option::Option<Vec<crate::app_rocksky::dropbox::FileView<'a>>>,
30
+
}
31
+
32
+
#[jacquard_derive::lexicon]
33
+
#[derive(
34
+
serde::Serialize,
35
+
serde::Deserialize,
36
+
Debug,
37
+
Clone,
38
+
PartialEq,
39
+
Eq,
40
+
jacquard_derive::IntoStatic,
41
+
Default
42
+
)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct FileView<'a> {
45
+
/// The last modified date and time of the file on the client.
46
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
47
+
pub client_modified: std::option::Option<jacquard_common::types::string::Datetime>,
48
+
/// The unique identifier of the file.
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[serde(borrow)]
51
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
52
+
/// The name of the file.
53
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
54
+
#[serde(borrow)]
55
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
56
+
/// The display path of the file.
57
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
+
#[serde(borrow)]
59
+
pub path_display: std::option::Option<jacquard_common::CowStr<'a>>,
60
+
/// The lowercased path of the file.
61
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
62
+
#[serde(borrow)]
63
+
pub path_lower: std::option::Option<jacquard_common::CowStr<'a>>,
64
+
/// The last modified date and time of the file on the server.
65
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
66
+
pub server_modified: std::option::Option<jacquard_common::types::string::Datetime>,
67
+
}
68
+
69
+
#[jacquard_derive::lexicon]
70
+
#[derive(
71
+
serde::Serialize,
72
+
serde::Deserialize,
73
+
Debug,
74
+
Clone,
75
+
PartialEq,
76
+
Eq,
77
+
jacquard_derive::IntoStatic,
78
+
Default
79
+
)]
80
+
#[serde(rename_all = "camelCase")]
81
+
pub struct TemporaryLinkView<'a> {
82
+
/// The temporary link to access the file.
83
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
84
+
#[serde(borrow)]
85
+
pub link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
86
+
}
+67
crates/jacquard-api/src/app_rocksky/feed/get_now_playings.rs
+67
crates/jacquard-api/src/app_rocksky/feed/get_now_playings.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.feed.getNowPlayings
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetNowPlayings {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub size: std::option::Option<i64>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetNowPlayingsOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::feed::NowPlayingsView<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.feed.getNowPlayings
45
+
pub struct GetNowPlayingsResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetNowPlayingsResponse {
47
+
const NSID: &'static str = "app.rocksky.feed.getNowPlayings";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetNowPlayingsOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl jacquard_common::xrpc::XrpcRequest for GetNowPlayings {
54
+
const NSID: &'static str = "app.rocksky.feed.getNowPlayings";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetNowPlayingsResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.feed.getNowPlayings
61
+
pub struct GetNowPlayingsRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetNowPlayingsRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.feed.getNowPlayings";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetNowPlayings;
66
+
type Response = GetNowPlayingsResponse;
67
+
}
+67
crates/jacquard-api/src/app_rocksky/feed/search.rs
+67
crates/jacquard-api/src/app_rocksky/feed/search.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.feed.search
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct Search<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub query: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct SearchOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::feed::SearchResultsView<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.feed.search
45
+
pub struct SearchResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for SearchResponse {
47
+
const NSID: &'static str = "app.rocksky.feed.search";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = SearchOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for Search<'a> {
54
+
const NSID: &'static str = "app.rocksky.feed.search";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = SearchResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.feed.search
61
+
pub struct SearchRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for SearchRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.feed.search";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = Search<'de>;
66
+
type Response = SearchResponse;
67
+
}
+140
crates/jacquard-api/src/app_rocksky/feed.rs
+140
crates/jacquard-api/src/app_rocksky/feed.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.feed.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_now_playings;
9
+
pub mod search;
10
+
11
+
#[jacquard_derive::lexicon]
12
+
#[derive(
13
+
serde::Serialize,
14
+
serde::Deserialize,
15
+
Debug,
16
+
Clone,
17
+
PartialEq,
18
+
Eq,
19
+
jacquard_derive::IntoStatic,
20
+
Default
21
+
)]
22
+
#[serde(rename_all = "camelCase")]
23
+
pub struct NowPlayingView<'a> {
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
#[serde(borrow)]
26
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
#[serde(borrow)]
29
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[serde(borrow)]
32
+
pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,
33
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
34
+
#[serde(borrow)]
35
+
pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
36
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
37
+
#[serde(borrow)]
38
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
39
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
40
+
#[serde(borrow)]
41
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
42
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
43
+
#[serde(borrow)]
44
+
pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub created_at: std::option::Option<jacquard_common::CowStr<'a>>,
48
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
49
+
#[serde(borrow)]
50
+
pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
51
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
52
+
#[serde(borrow)]
53
+
pub handle: std::option::Option<jacquard_common::CowStr<'a>>,
54
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
55
+
#[serde(borrow)]
56
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
57
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
+
#[serde(borrow)]
59
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
60
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
61
+
#[serde(borrow)]
62
+
pub track_id: std::option::Option<jacquard_common::CowStr<'a>>,
63
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
64
+
#[serde(borrow)]
65
+
pub track_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
66
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
67
+
#[serde(borrow)]
68
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
69
+
}
70
+
71
+
#[jacquard_derive::lexicon]
72
+
#[derive(
73
+
serde::Serialize,
74
+
serde::Deserialize,
75
+
Debug,
76
+
Clone,
77
+
PartialEq,
78
+
Eq,
79
+
jacquard_derive::IntoStatic,
80
+
Default
81
+
)]
82
+
#[serde(rename_all = "camelCase")]
83
+
pub struct NowPlayingsView<'a> {
84
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
85
+
#[serde(borrow)]
86
+
pub now_playings: std::option::Option<
87
+
Vec<crate::app_rocksky::feed::NowPlayingView<'a>>,
88
+
>,
89
+
}
90
+
91
+
#[jacquard_derive::lexicon]
92
+
#[derive(
93
+
serde::Serialize,
94
+
serde::Deserialize,
95
+
Debug,
96
+
Clone,
97
+
PartialEq,
98
+
Eq,
99
+
jacquard_derive::IntoStatic,
100
+
Default
101
+
)]
102
+
#[serde(rename_all = "camelCase")]
103
+
pub struct SearchResultsView<'a> {
104
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
105
+
pub estimated_total_hits: std::option::Option<i64>,
106
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
107
+
#[serde(borrow)]
108
+
pub hits: std::option::Option<Vec<SearchResultsViewHitsItem<'a>>>,
109
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
110
+
pub limit: std::option::Option<i64>,
111
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
112
+
pub offset: std::option::Option<i64>,
113
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
114
+
pub processing_time_ms: std::option::Option<i64>,
115
+
}
116
+
117
+
#[jacquard_derive::open_union]
118
+
#[derive(
119
+
serde::Serialize,
120
+
serde::Deserialize,
121
+
Debug,
122
+
Clone,
123
+
PartialEq,
124
+
Eq,
125
+
jacquard_derive::IntoStatic
126
+
)]
127
+
#[serde(tag = "$type")]
128
+
#[serde(bound(deserialize = "'de: 'a"))]
129
+
pub enum SearchResultsViewHitsItem<'a> {
130
+
#[serde(rename = "app.rocksky.song.defs#songViewBasic")]
131
+
SongViewBasic(Box<crate::app_rocksky::song::SongViewBasic<'a>>),
132
+
#[serde(rename = "app.rocksky.album.defs#albumViewBasic")]
133
+
AlbumViewBasic(Box<crate::app_rocksky::album::AlbumViewBasic<'a>>),
134
+
#[serde(rename = "app.rocksky.artist.defs#artistViewBasic")]
135
+
ArtistViewBasic(Box<crate::app_rocksky::artist::ArtistViewBasic<'a>>),
136
+
#[serde(rename = "app.rocksky.playlist.defs#playlistViewBasic")]
137
+
PlaylistViewBasic(Box<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>),
138
+
#[serde(rename = "app.rocksky.actor.defs#profileViewBasic")]
139
+
ProfileViewBasic(Box<crate::app_rocksky::actor::ProfileViewBasic<'a>>),
140
+
}
+62
crates/jacquard-api/src/app_rocksky/googledrive/download_file.rs
+62
crates/jacquard-api/src/app_rocksky/googledrive/download_file.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.googledrive.downloadFile
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct DownloadFile<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub file_id: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct DownloadFileOutput<'a> {}
38
+
///Response type for
39
+
///app.rocksky.googledrive.downloadFile
40
+
pub struct DownloadFileResponse;
41
+
impl jacquard_common::xrpc::XrpcResp for DownloadFileResponse {
42
+
const NSID: &'static str = "app.rocksky.googledrive.downloadFile";
43
+
const ENCODING: &'static str = "application/octet-stream";
44
+
type Output<'de> = DownloadFileOutput<'de>;
45
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
46
+
}
47
+
48
+
impl<'a> jacquard_common::xrpc::XrpcRequest for DownloadFile<'a> {
49
+
const NSID: &'static str = "app.rocksky.googledrive.downloadFile";
50
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
51
+
type Response = DownloadFileResponse;
52
+
}
53
+
54
+
///Endpoint type for
55
+
///app.rocksky.googledrive.downloadFile
56
+
pub struct DownloadFileRequest;
57
+
impl jacquard_common::xrpc::XrpcEndpoint for DownloadFileRequest {
58
+
const PATH: &'static str = "/xrpc/app.rocksky.googledrive.downloadFile";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
60
+
type Request<'de> = DownloadFile<'de>;
61
+
type Response = DownloadFileResponse;
62
+
}
+67
crates/jacquard-api/src/app_rocksky/googledrive/get_file.rs
+67
crates/jacquard-api/src/app_rocksky/googledrive/get_file.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.googledrive.getFile
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetFile<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub file_id: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetFileOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::googledrive::FileView<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.googledrive.getFile
45
+
pub struct GetFileResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetFileResponse {
47
+
const NSID: &'static str = "app.rocksky.googledrive.getFile";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetFileOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetFile<'a> {
54
+
const NSID: &'static str = "app.rocksky.googledrive.getFile";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetFileResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.googledrive.getFile
61
+
pub struct GetFileRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetFileRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.googledrive.getFile";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetFile<'de>;
66
+
type Response = GetFileResponse;
67
+
}
+68
crates/jacquard-api/src/app_rocksky/googledrive/get_files.rs
+68
crates/jacquard-api/src/app_rocksky/googledrive/get_files.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.googledrive.getFiles
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetFiles<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
#[builder(into)]
24
+
pub at: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct GetFilesOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::googledrive::FileListView<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.googledrive.getFiles
46
+
pub struct GetFilesResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for GetFilesResponse {
48
+
const NSID: &'static str = "app.rocksky.googledrive.getFiles";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = GetFilesOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetFiles<'a> {
55
+
const NSID: &'static str = "app.rocksky.googledrive.getFiles";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
57
+
type Response = GetFilesResponse;
58
+
}
59
+
60
+
///Endpoint type for
61
+
///app.rocksky.googledrive.getFiles
62
+
pub struct GetFilesRequest;
63
+
impl jacquard_common::xrpc::XrpcEndpoint for GetFilesRequest {
64
+
const PATH: &'static str = "/xrpc/app.rocksky.googledrive.getFiles";
65
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
66
+
type Request<'de> = GetFiles<'de>;
67
+
type Response = GetFilesResponse;
68
+
}
+47
crates/jacquard-api/src/app_rocksky/googledrive.rs
+47
crates/jacquard-api/src/app_rocksky/googledrive.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.googledrive.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod download_file;
9
+
pub mod get_file;
10
+
pub mod get_files;
11
+
12
+
#[jacquard_derive::lexicon]
13
+
#[derive(
14
+
serde::Serialize,
15
+
serde::Deserialize,
16
+
Debug,
17
+
Clone,
18
+
PartialEq,
19
+
Eq,
20
+
jacquard_derive::IntoStatic,
21
+
Default
22
+
)]
23
+
#[serde(rename_all = "camelCase")]
24
+
pub struct FileListView<'a> {
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
#[serde(borrow)]
27
+
pub files: std::option::Option<Vec<crate::app_rocksky::googledrive::FileView<'a>>>,
28
+
}
29
+
30
+
#[jacquard_derive::lexicon]
31
+
#[derive(
32
+
serde::Serialize,
33
+
serde::Deserialize,
34
+
Debug,
35
+
Clone,
36
+
PartialEq,
37
+
Eq,
38
+
jacquard_derive::IntoStatic,
39
+
Default
40
+
)]
41
+
#[serde(rename_all = "camelCase")]
42
+
pub struct FileView<'a> {
43
+
/// The unique identifier of the file.
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
47
+
}
+72
crates/jacquard-api/src/app_rocksky/like/dislike_shout.rs
+72
crates/jacquard-api/src/app_rocksky/like/dislike_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.like.dislikeShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct DislikeShout<'a> {
21
+
/// The unique identifier of the shout to dislike
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct DislikeShoutOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.like.dislikeShout
46
+
pub struct DislikeShoutResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for DislikeShoutResponse {
48
+
const NSID: &'static str = "app.rocksky.like.dislikeShout";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = DislikeShoutOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for DislikeShout<'a> {
55
+
const NSID: &'static str = "app.rocksky.like.dislikeShout";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
57
+
"application/json",
58
+
);
59
+
type Response = DislikeShoutResponse;
60
+
}
61
+
62
+
///Endpoint type for
63
+
///app.rocksky.like.dislikeShout
64
+
pub struct DislikeShoutRequest;
65
+
impl jacquard_common::xrpc::XrpcEndpoint for DislikeShoutRequest {
66
+
const PATH: &'static str = "/xrpc/app.rocksky.like.dislikeShout";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Request<'de> = DislikeShout<'de>;
71
+
type Response = DislikeShoutResponse;
72
+
}
+72
crates/jacquard-api/src/app_rocksky/like/dislike_song.rs
+72
crates/jacquard-api/src/app_rocksky/like/dislike_song.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.like.dislikeSong
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct DislikeSong<'a> {
21
+
/// The unique identifier of the song to dislike
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct DislikeSongOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::song::SongViewDetailed<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.like.dislikeSong
46
+
pub struct DislikeSongResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for DislikeSongResponse {
48
+
const NSID: &'static str = "app.rocksky.like.dislikeSong";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = DislikeSongOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for DislikeSong<'a> {
55
+
const NSID: &'static str = "app.rocksky.like.dislikeSong";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
57
+
"application/json",
58
+
);
59
+
type Response = DislikeSongResponse;
60
+
}
61
+
62
+
///Endpoint type for
63
+
///app.rocksky.like.dislikeSong
64
+
pub struct DislikeSongRequest;
65
+
impl jacquard_common::xrpc::XrpcEndpoint for DislikeSongRequest {
66
+
const PATH: &'static str = "/xrpc/app.rocksky.like.dislikeSong";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Request<'de> = DislikeSong<'de>;
71
+
type Response = DislikeSongResponse;
72
+
}
+72
crates/jacquard-api/src/app_rocksky/like/like_shout.rs
+72
crates/jacquard-api/src/app_rocksky/like/like_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.like.likeShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct LikeShout<'a> {
21
+
/// The unique identifier of the shout to like
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct LikeShoutOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.like.likeShout
46
+
pub struct LikeShoutResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for LikeShoutResponse {
48
+
const NSID: &'static str = "app.rocksky.like.likeShout";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = LikeShoutOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for LikeShout<'a> {
55
+
const NSID: &'static str = "app.rocksky.like.likeShout";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
57
+
"application/json",
58
+
);
59
+
type Response = LikeShoutResponse;
60
+
}
61
+
62
+
///Endpoint type for
63
+
///app.rocksky.like.likeShout
64
+
pub struct LikeShoutRequest;
65
+
impl jacquard_common::xrpc::XrpcEndpoint for LikeShoutRequest {
66
+
const PATH: &'static str = "/xrpc/app.rocksky.like.likeShout";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Request<'de> = LikeShout<'de>;
71
+
type Response = LikeShoutResponse;
72
+
}
+72
crates/jacquard-api/src/app_rocksky/like/like_song.rs
+72
crates/jacquard-api/src/app_rocksky/like/like_song.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.like.likeSong
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct LikeSong<'a> {
21
+
/// The unique identifier of the song to like
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct LikeSongOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::song::SongViewDetailed<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.like.likeSong
46
+
pub struct LikeSongResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for LikeSongResponse {
48
+
const NSID: &'static str = "app.rocksky.like.likeSong";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = LikeSongOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for LikeSong<'a> {
55
+
const NSID: &'static str = "app.rocksky.like.likeSong";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
57
+
"application/json",
58
+
);
59
+
type Response = LikeSongResponse;
60
+
}
61
+
62
+
///Endpoint type for
63
+
///app.rocksky.like.likeSong
64
+
pub struct LikeSongRequest;
65
+
impl jacquard_common::xrpc::XrpcEndpoint for LikeSongRequest {
66
+
const PATH: &'static str = "/xrpc/app.rocksky.like.likeSong";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Request<'de> = LikeSong<'de>;
71
+
type Response = LikeSongResponse;
72
+
}
+73
crates/jacquard-api/src/app_rocksky/like.rs
+73
crates/jacquard-api/src/app_rocksky/like.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.like
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod dislike_shout;
9
+
pub mod dislike_song;
10
+
pub mod like_shout;
11
+
pub mod like_song;
12
+
13
+
/// A declaration of a like.
14
+
#[jacquard_derive::lexicon]
15
+
#[derive(
16
+
serde::Serialize,
17
+
serde::Deserialize,
18
+
Debug,
19
+
Clone,
20
+
PartialEq,
21
+
Eq,
22
+
jacquard_derive::IntoStatic,
23
+
bon::Builder
24
+
)]
25
+
#[serde(rename_all = "camelCase")]
26
+
pub struct Like<'a> {
27
+
/// The date when the like was created.
28
+
pub created_at: jacquard_common::types::string::Datetime,
29
+
#[serde(borrow)]
30
+
pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
31
+
}
32
+
33
+
/// Typed wrapper for GetRecord response with this collection's record type.
34
+
#[derive(
35
+
serde::Serialize,
36
+
serde::Deserialize,
37
+
Debug,
38
+
Clone,
39
+
PartialEq,
40
+
Eq,
41
+
jacquard_derive::IntoStatic
42
+
)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct LikeGetRecordOutput<'a> {
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
48
+
#[serde(borrow)]
49
+
pub uri: jacquard_common::types::string::AtUri<'a>,
50
+
#[serde(borrow)]
51
+
pub value: Like<'a>,
52
+
}
53
+
54
+
/// Marker type for deserializing records from this collection.
55
+
pub struct LikeRecord;
56
+
impl jacquard_common::xrpc::XrpcResp for LikeRecord {
57
+
const NSID: &'static str = "app.rocksky.like";
58
+
const ENCODING: &'static str = "application/json";
59
+
type Output<'de> = LikeGetRecordOutput<'de>;
60
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
61
+
}
62
+
63
+
impl jacquard_common::types::collection::Collection for Like<'_> {
64
+
const NSID: &'static str = "app.rocksky.like";
65
+
type Record = LikeRecord;
66
+
}
67
+
68
+
impl From<LikeGetRecordOutput<'_>> for Like<'_> {
69
+
fn from(output: LikeGetRecordOutput<'_>) -> Self {
70
+
use jacquard_common::IntoStatic;
71
+
output.value.into_static()
72
+
}
73
+
}
+67
crates/jacquard-api/src/app_rocksky/player/get_currently_playing.rs
+67
crates/jacquard-api/src/app_rocksky/player/get_currently_playing.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.getCurrentlyPlaying
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetCurrentlyPlaying<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
pub actor: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetCurrentlyPlayingOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::player::CurrentlyPlayingViewDetailed<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.player.getCurrentlyPlaying
45
+
pub struct GetCurrentlyPlayingResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetCurrentlyPlayingResponse {
47
+
const NSID: &'static str = "app.rocksky.player.getCurrentlyPlaying";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetCurrentlyPlayingOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetCurrentlyPlaying<'a> {
54
+
const NSID: &'static str = "app.rocksky.player.getCurrentlyPlaying";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetCurrentlyPlayingResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.player.getCurrentlyPlaying
61
+
pub struct GetCurrentlyPlayingRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetCurrentlyPlayingRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.player.getCurrentlyPlaying";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetCurrentlyPlaying<'de>;
66
+
type Response = GetCurrentlyPlayingResponse;
67
+
}
+48
crates/jacquard-api/src/app_rocksky/player/next.rs
+48
crates/jacquard-api/src/app_rocksky/player/next.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.next
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Next;
20
+
///Response type for
21
+
///app.rocksky.player.next
22
+
pub struct NextResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for NextResponse {
24
+
const NSID: &'static str = "app.rocksky.player.next";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Next {
31
+
const NSID: &'static str = "app.rocksky.player.next";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = NextResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.player.next
40
+
pub struct NextRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for NextRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.player.next";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Next;
47
+
type Response = NextResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/player/pause.rs
+48
crates/jacquard-api/src/app_rocksky/player/pause.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.pause
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Pause;
20
+
///Response type for
21
+
///app.rocksky.player.pause
22
+
pub struct PauseResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PauseResponse {
24
+
const NSID: &'static str = "app.rocksky.player.pause";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Pause {
31
+
const NSID: &'static str = "app.rocksky.player.pause";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PauseResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.player.pause
40
+
pub struct PauseRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PauseRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.player.pause";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Pause;
47
+
type Response = PauseResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/player/play.rs
+48
crates/jacquard-api/src/app_rocksky/player/play.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.play
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Play;
20
+
///Response type for
21
+
///app.rocksky.player.play
22
+
pub struct PlayResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PlayResponse {
24
+
const NSID: &'static str = "app.rocksky.player.play";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Play {
31
+
const NSID: &'static str = "app.rocksky.player.play";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PlayResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.player.play
40
+
pub struct PlayRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PlayRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.player.play";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Play;
47
+
type Response = PlayResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/player/previous.rs
+48
crates/jacquard-api/src/app_rocksky/player/previous.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.previous
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Previous;
20
+
///Response type for
21
+
///app.rocksky.player.previous
22
+
pub struct PreviousResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PreviousResponse {
24
+
const NSID: &'static str = "app.rocksky.player.previous";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Previous {
31
+
const NSID: &'static str = "app.rocksky.player.previous";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PreviousResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.player.previous
40
+
pub struct PreviousRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PreviousRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.player.previous";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Previous;
47
+
type Response = PreviousResponse;
48
+
}
+64
crates/jacquard-api/src/app_rocksky/player/seek.rs
+64
crates/jacquard-api/src/app_rocksky/player/seek.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.seek
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct SeekParams {
21
+
pub position: i64,
22
+
}
23
+
24
+
/// XRPC request marker type
25
+
#[derive(
26
+
Debug,
27
+
Clone,
28
+
Copy,
29
+
PartialEq,
30
+
Eq,
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
pub struct Seek;
36
+
///Response type for
37
+
///app.rocksky.player.seek
38
+
pub struct SeekResponse;
39
+
impl jacquard_common::xrpc::XrpcResp for SeekResponse {
40
+
const NSID: &'static str = "app.rocksky.player.seek";
41
+
const ENCODING: &'static str = "application/json";
42
+
type Output<'de> = ();
43
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
44
+
}
45
+
46
+
impl jacquard_common::xrpc::XrpcRequest for Seek {
47
+
const NSID: &'static str = "app.rocksky.player.seek";
48
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
49
+
"application/json",
50
+
);
51
+
type Response = SeekResponse;
52
+
}
53
+
54
+
///Endpoint type for
55
+
///app.rocksky.player.seek
56
+
pub struct SeekRequest;
57
+
impl jacquard_common::xrpc::XrpcEndpoint for SeekRequest {
58
+
const PATH: &'static str = "/xrpc/app.rocksky.player.seek";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
60
+
"application/json",
61
+
);
62
+
type Request<'de> = Seek;
63
+
type Response = SeekResponse;
64
+
}
+32
crates/jacquard-api/src/app_rocksky/player.rs
+32
crates/jacquard-api/src/app_rocksky/player.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.player.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_currently_playing;
9
+
pub mod next;
10
+
pub mod pause;
11
+
pub mod play;
12
+
pub mod previous;
13
+
pub mod seek;
14
+
15
+
#[jacquard_derive::lexicon]
16
+
#[derive(
17
+
serde::Serialize,
18
+
serde::Deserialize,
19
+
Debug,
20
+
Clone,
21
+
PartialEq,
22
+
Eq,
23
+
jacquard_derive::IntoStatic,
24
+
Default
25
+
)]
26
+
#[serde(rename_all = "camelCase")]
27
+
pub struct CurrentlyPlayingViewDetailed<'a> {
28
+
/// The title of the currently playing track
29
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
30
+
#[serde(borrow)]
31
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
32
+
}
+66
crates/jacquard-api/src/app_rocksky/playlist/get_playlist.rs
+66
crates/jacquard-api/src/app_rocksky/playlist/get_playlist.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.playlist.getPlaylist
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetPlaylist<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetPlaylistOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::playlist::PlaylistViewDetailed<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.playlist.getPlaylist
44
+
pub struct GetPlaylistResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetPlaylistResponse {
46
+
const NSID: &'static str = "app.rocksky.playlist.getPlaylist";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetPlaylistOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetPlaylist<'a> {
53
+
const NSID: &'static str = "app.rocksky.playlist.getPlaylist";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetPlaylistResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.playlist.getPlaylist
60
+
pub struct GetPlaylistRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetPlaylistRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.playlist.getPlaylist";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetPlaylist<'de>;
65
+
type Response = GetPlaylistResponse;
66
+
}
+71
crates/jacquard-api/src/app_rocksky/playlist/get_playlists.rs
+71
crates/jacquard-api/src/app_rocksky/playlist/get_playlists.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.playlist.getPlaylists
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetPlaylists {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
pub limit: std::option::Option<i64>,
23
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
24
+
pub offset: std::option::Option<i64>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic,
36
+
Default
37
+
)]
38
+
#[serde(rename_all = "camelCase")]
39
+
pub struct GetPlaylistsOutput<'a> {
40
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
41
+
#[serde(borrow)]
42
+
pub playlists: std::option::Option<
43
+
Vec<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>,
44
+
>,
45
+
}
46
+
47
+
///Response type for
48
+
///app.rocksky.playlist.getPlaylists
49
+
pub struct GetPlaylistsResponse;
50
+
impl jacquard_common::xrpc::XrpcResp for GetPlaylistsResponse {
51
+
const NSID: &'static str = "app.rocksky.playlist.getPlaylists";
52
+
const ENCODING: &'static str = "application/json";
53
+
type Output<'de> = GetPlaylistsOutput<'de>;
54
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
55
+
}
56
+
57
+
impl jacquard_common::xrpc::XrpcRequest for GetPlaylists {
58
+
const NSID: &'static str = "app.rocksky.playlist.getPlaylists";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
60
+
type Response = GetPlaylistsResponse;
61
+
}
62
+
63
+
///Endpoint type for
64
+
///app.rocksky.playlist.getPlaylists
65
+
pub struct GetPlaylistsRequest;
66
+
impl jacquard_common::xrpc::XrpcEndpoint for GetPlaylistsRequest {
67
+
const PATH: &'static str = "/xrpc/app.rocksky.playlist.getPlaylists";
68
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
69
+
type Request<'de> = GetPlaylists;
70
+
type Response = GetPlaylistsResponse;
71
+
}
+233
crates/jacquard-api/src/app_rocksky/playlist.rs
+233
crates/jacquard-api/src/app_rocksky/playlist.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.playlist.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_playlist;
9
+
pub mod get_playlists;
10
+
11
+
/// A declaration of a playlist.
12
+
#[jacquard_derive::lexicon]
13
+
#[derive(
14
+
serde::Serialize,
15
+
serde::Deserialize,
16
+
Debug,
17
+
Clone,
18
+
PartialEq,
19
+
Eq,
20
+
jacquard_derive::IntoStatic,
21
+
bon::Builder
22
+
)]
23
+
#[serde(rename_all = "camelCase")]
24
+
pub struct Playlist<'a> {
25
+
/// The Apple Music link of the playlist.
26
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
27
+
#[builder(into)]
28
+
#[serde(borrow)]
29
+
pub apple_music_link: Option<jacquard_common::CowStr<'a>>,
30
+
/// The date the playlist was created.
31
+
pub created_at: jacquard_common::types::string::Datetime,
32
+
/// The playlist description.
33
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
34
+
#[builder(into)]
35
+
#[serde(borrow)]
36
+
pub description: Option<jacquard_common::CowStr<'a>>,
37
+
/// The name of the playlist.
38
+
#[serde(borrow)]
39
+
#[builder(into)]
40
+
pub name: jacquard_common::CowStr<'a>,
41
+
/// The picture of the playlist.
42
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
43
+
#[builder(into)]
44
+
#[serde(borrow)]
45
+
pub picture: Option<jacquard_common::types::blob::Blob<'a>>,
46
+
/// The Spotify link of the playlist.
47
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
48
+
#[builder(into)]
49
+
#[serde(borrow)]
50
+
pub spotify_link: Option<jacquard_common::CowStr<'a>>,
51
+
/// The Tidal link of the playlist.
52
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
53
+
#[builder(into)]
54
+
#[serde(borrow)]
55
+
pub tidal_link: Option<jacquard_common::CowStr<'a>>,
56
+
/// The tracks in the playlist.
57
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
+
#[builder(into)]
59
+
#[serde(borrow)]
60
+
pub tracks: Option<Vec<jacquard_common::types::value::Data<'a>>>,
61
+
/// The YouTube link of the playlist.
62
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
63
+
#[builder(into)]
64
+
#[serde(borrow)]
65
+
pub youtube_link: Option<jacquard_common::CowStr<'a>>,
66
+
}
67
+
68
+
/// Typed wrapper for GetRecord response with this collection's record type.
69
+
#[derive(
70
+
serde::Serialize,
71
+
serde::Deserialize,
72
+
Debug,
73
+
Clone,
74
+
PartialEq,
75
+
Eq,
76
+
jacquard_derive::IntoStatic
77
+
)]
78
+
#[serde(rename_all = "camelCase")]
79
+
pub struct PlaylistGetRecordOutput<'a> {
80
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
81
+
#[serde(borrow)]
82
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
83
+
#[serde(borrow)]
84
+
pub uri: jacquard_common::types::string::AtUri<'a>,
85
+
#[serde(borrow)]
86
+
pub value: Playlist<'a>,
87
+
}
88
+
89
+
/// Marker type for deserializing records from this collection.
90
+
pub struct PlaylistRecord;
91
+
impl jacquard_common::xrpc::XrpcResp for PlaylistRecord {
92
+
const NSID: &'static str = "app.rocksky.playlist";
93
+
const ENCODING: &'static str = "application/json";
94
+
type Output<'de> = PlaylistGetRecordOutput<'de>;
95
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
96
+
}
97
+
98
+
impl jacquard_common::types::collection::Collection for Playlist<'_> {
99
+
const NSID: &'static str = "app.rocksky.playlist";
100
+
type Record = PlaylistRecord;
101
+
}
102
+
103
+
impl From<PlaylistGetRecordOutput<'_>> for Playlist<'_> {
104
+
fn from(output: PlaylistGetRecordOutput<'_>) -> Self {
105
+
use jacquard_common::IntoStatic;
106
+
output.value.into_static()
107
+
}
108
+
}
109
+
110
+
/// Basic view of a playlist, including its metadata
111
+
#[jacquard_derive::lexicon]
112
+
#[derive(
113
+
serde::Serialize,
114
+
serde::Deserialize,
115
+
Debug,
116
+
Clone,
117
+
PartialEq,
118
+
Eq,
119
+
jacquard_derive::IntoStatic,
120
+
Default
121
+
)]
122
+
#[serde(rename_all = "camelCase")]
123
+
pub struct PlaylistViewBasic<'a> {
124
+
/// The URL of the cover image for the playlist.
125
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
126
+
#[serde(borrow)]
127
+
pub cover_image_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
128
+
/// The date and time when the playlist was created.
129
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
130
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
131
+
/// The URL of the avatar image of the curator.
132
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
133
+
#[serde(borrow)]
134
+
pub curator_avatar_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
135
+
/// The DID of the curator of the playlist.
136
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
137
+
#[serde(borrow)]
138
+
pub curator_did: std::option::Option<
139
+
jacquard_common::types::ident::AtIdentifier<'a>,
140
+
>,
141
+
/// The handle of the curator of the playlist.
142
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
143
+
#[serde(borrow)]
144
+
pub curator_handle: std::option::Option<
145
+
jacquard_common::types::ident::AtIdentifier<'a>,
146
+
>,
147
+
/// The name of the curator of the playlist.
148
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
149
+
#[serde(borrow)]
150
+
pub curator_name: std::option::Option<jacquard_common::CowStr<'a>>,
151
+
/// A description of the playlist.
152
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
153
+
#[serde(borrow)]
154
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
155
+
/// The unique identifier of the playlist.
156
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
157
+
#[serde(borrow)]
158
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
159
+
/// The title of the playlist.
160
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
161
+
#[serde(borrow)]
162
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
163
+
/// The number of tracks in the playlist.
164
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
165
+
pub track_count: std::option::Option<i64>,
166
+
/// The URI of the playlist.
167
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
168
+
#[serde(borrow)]
169
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
170
+
}
171
+
172
+
/// Detailed view of a playlist, including its tracks and metadata
173
+
#[jacquard_derive::lexicon]
174
+
#[derive(
175
+
serde::Serialize,
176
+
serde::Deserialize,
177
+
Debug,
178
+
Clone,
179
+
PartialEq,
180
+
Eq,
181
+
jacquard_derive::IntoStatic,
182
+
Default
183
+
)]
184
+
#[serde(rename_all = "camelCase")]
185
+
pub struct PlaylistViewDetailed<'a> {
186
+
/// The URL of the cover image for the playlist.
187
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
188
+
#[serde(borrow)]
189
+
pub cover_image_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
190
+
/// The date and time when the playlist was created.
191
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
192
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
193
+
/// The URL of the avatar image of the curator.
194
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
195
+
#[serde(borrow)]
196
+
pub curator_avatar_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
197
+
/// The DID of the curator of the playlist.
198
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
199
+
#[serde(borrow)]
200
+
pub curator_did: std::option::Option<
201
+
jacquard_common::types::ident::AtIdentifier<'a>,
202
+
>,
203
+
/// The handle of the curator of the playlist.
204
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
205
+
#[serde(borrow)]
206
+
pub curator_handle: std::option::Option<
207
+
jacquard_common::types::ident::AtIdentifier<'a>,
208
+
>,
209
+
/// The name of the curator of the playlist.
210
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
211
+
#[serde(borrow)]
212
+
pub curator_name: std::option::Option<jacquard_common::CowStr<'a>>,
213
+
/// A description of the playlist.
214
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
215
+
#[serde(borrow)]
216
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
217
+
/// The unique identifier of the playlist.
218
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
219
+
#[serde(borrow)]
220
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
221
+
/// The title of the playlist.
222
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
223
+
#[serde(borrow)]
224
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
225
+
/// A list of tracks in the playlist.
226
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
227
+
#[serde(borrow)]
228
+
pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
229
+
/// The URI of the playlist.
230
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
231
+
#[serde(borrow)]
232
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
233
+
}
+169
crates/jacquard-api/src/app_rocksky/radio.rs
+169
crates/jacquard-api/src/app_rocksky/radio.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.radio.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// A declaration of a radio station.
9
+
#[jacquard_derive::lexicon]
10
+
#[derive(
11
+
serde::Serialize,
12
+
serde::Deserialize,
13
+
Debug,
14
+
Clone,
15
+
PartialEq,
16
+
Eq,
17
+
jacquard_derive::IntoStatic,
18
+
bon::Builder
19
+
)]
20
+
#[serde(rename_all = "camelCase")]
21
+
pub struct Radio<'a> {
22
+
/// The date when the radio station was created.
23
+
pub created_at: jacquard_common::types::string::Datetime,
24
+
/// A description of the radio station.
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
#[builder(into)]
27
+
#[serde(borrow)]
28
+
pub description: Option<jacquard_common::CowStr<'a>>,
29
+
/// The genre of the radio station.
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[builder(into)]
32
+
#[serde(borrow)]
33
+
pub genre: Option<jacquard_common::CowStr<'a>>,
34
+
/// The logo of the radio station.
35
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
36
+
#[builder(into)]
37
+
#[serde(borrow)]
38
+
pub logo: Option<jacquard_common::types::blob::Blob<'a>>,
39
+
/// The name of the radio station.
40
+
#[serde(borrow)]
41
+
#[builder(into)]
42
+
pub name: jacquard_common::CowStr<'a>,
43
+
/// The URL of the radio station.
44
+
#[serde(borrow)]
45
+
pub url: jacquard_common::types::string::Uri<'a>,
46
+
/// The website of the radio station.
47
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
48
+
#[builder(into)]
49
+
#[serde(borrow)]
50
+
pub website: Option<jacquard_common::types::string::Uri<'a>>,
51
+
}
52
+
53
+
/// Typed wrapper for GetRecord response with this collection's record type.
54
+
#[derive(
55
+
serde::Serialize,
56
+
serde::Deserialize,
57
+
Debug,
58
+
Clone,
59
+
PartialEq,
60
+
Eq,
61
+
jacquard_derive::IntoStatic
62
+
)]
63
+
#[serde(rename_all = "camelCase")]
64
+
pub struct RadioGetRecordOutput<'a> {
65
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
66
+
#[serde(borrow)]
67
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
68
+
#[serde(borrow)]
69
+
pub uri: jacquard_common::types::string::AtUri<'a>,
70
+
#[serde(borrow)]
71
+
pub value: Radio<'a>,
72
+
}
73
+
74
+
/// Marker type for deserializing records from this collection.
75
+
pub struct RadioRecord;
76
+
impl jacquard_common::xrpc::XrpcResp for RadioRecord {
77
+
const NSID: &'static str = "app.rocksky.radio";
78
+
const ENCODING: &'static str = "application/json";
79
+
type Output<'de> = RadioGetRecordOutput<'de>;
80
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
81
+
}
82
+
83
+
impl jacquard_common::types::collection::Collection for Radio<'_> {
84
+
const NSID: &'static str = "app.rocksky.radio";
85
+
type Record = RadioRecord;
86
+
}
87
+
88
+
impl From<RadioGetRecordOutput<'_>> for Radio<'_> {
89
+
fn from(output: RadioGetRecordOutput<'_>) -> Self {
90
+
use jacquard_common::IntoStatic;
91
+
output.value.into_static()
92
+
}
93
+
}
94
+
95
+
#[jacquard_derive::lexicon]
96
+
#[derive(
97
+
serde::Serialize,
98
+
serde::Deserialize,
99
+
Debug,
100
+
Clone,
101
+
PartialEq,
102
+
Eq,
103
+
jacquard_derive::IntoStatic,
104
+
Default
105
+
)]
106
+
#[serde(rename_all = "camelCase")]
107
+
pub struct RadioViewBasic<'a> {
108
+
/// The date and time when the radio was created.
109
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
110
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
111
+
/// A brief description of the radio.
112
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
113
+
#[serde(borrow)]
114
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
115
+
/// The unique identifier of the radio.
116
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
117
+
#[serde(borrow)]
118
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
119
+
/// The name of the radio.
120
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
121
+
#[serde(borrow)]
122
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
123
+
}
124
+
125
+
#[jacquard_derive::lexicon]
126
+
#[derive(
127
+
serde::Serialize,
128
+
serde::Deserialize,
129
+
Debug,
130
+
Clone,
131
+
PartialEq,
132
+
Eq,
133
+
jacquard_derive::IntoStatic,
134
+
Default
135
+
)]
136
+
#[serde(rename_all = "camelCase")]
137
+
pub struct RadioViewDetailed<'a> {
138
+
/// The date and time when the radio was created.
139
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
140
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
141
+
/// A brief description of the radio.
142
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
143
+
#[serde(borrow)]
144
+
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
145
+
/// The genre of the radio.
146
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
147
+
#[serde(borrow)]
148
+
pub genre: std::option::Option<jacquard_common::CowStr<'a>>,
149
+
/// The unique identifier of the radio.
150
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
151
+
#[serde(borrow)]
152
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
153
+
/// The logo of the radio station.
154
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
155
+
#[serde(borrow)]
156
+
pub logo: std::option::Option<jacquard_common::CowStr<'a>>,
157
+
/// The name of the radio.
158
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
159
+
#[serde(borrow)]
160
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
161
+
/// The streaming URL of the radio.
162
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
163
+
#[serde(borrow)]
164
+
pub url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
165
+
/// The website of the radio.
166
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
167
+
#[serde(borrow)]
168
+
pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,
169
+
}
+149
crates/jacquard-api/src/app_rocksky/scrobble/create_scrobble.rs
+149
crates/jacquard-api/src/app_rocksky/scrobble/create_scrobble.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.scrobble.createScrobble
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct CreateScrobble<'a> {
21
+
/// The album of the track being scrobbled
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
/// The URL of the album art for the track
26
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
27
+
#[serde(borrow)]
28
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
29
+
/// The Apple Music link for the track, if available
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
#[serde(borrow)]
32
+
pub apple_music_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
33
+
/// The artist of the track being scrobbled
34
+
#[serde(borrow)]
35
+
pub artist: jacquard_common::CowStr<'a>,
36
+
/// The URL of the artist's picture, if available
37
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
38
+
#[serde(borrow)]
39
+
pub artist_picture: std::option::Option<jacquard_common::types::string::Uri<'a>>,
40
+
/// The composer of the track, if available
41
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
42
+
#[serde(borrow)]
43
+
pub composer: std::option::Option<jacquard_common::CowStr<'a>>,
44
+
/// The copyright message for the track, if available
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub copyright_message: std::option::Option<jacquard_common::CowStr<'a>>,
48
+
/// The Deezer link for the track, if available
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[serde(borrow)]
51
+
pub deezer_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
52
+
/// The disc number of the track in the album, if applicable
53
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
54
+
pub disc_number: std::option::Option<i64>,
55
+
/// The duration of the track in seconds
56
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
57
+
pub duration: std::option::Option<i64>,
58
+
/// The record label of the track, if available
59
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
60
+
#[serde(borrow)]
61
+
pub label: std::option::Option<jacquard_common::CowStr<'a>>,
62
+
/// The Last.fm link for the track, if available
63
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
64
+
#[serde(borrow)]
65
+
pub lastfm_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
66
+
/// The lyrics of the track, if available
67
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
68
+
#[serde(borrow)]
69
+
pub lyrics: std::option::Option<jacquard_common::CowStr<'a>>,
70
+
/// The MusicBrainz ID of the track, if available
71
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
72
+
#[serde(borrow)]
73
+
pub mb_id: std::option::Option<jacquard_common::CowStr<'a>>,
74
+
/// The release date of the track, formatted as YYYY-MM-DD
75
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
76
+
#[serde(borrow)]
77
+
pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,
78
+
/// The Spotify link for the track, if available
79
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
80
+
#[serde(borrow)]
81
+
pub spotify_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
82
+
/// The Tidal link for the track, if available
83
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
84
+
#[serde(borrow)]
85
+
pub tidal_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
86
+
/// The timestamp of the scrobble in milliseconds since epoch
87
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
88
+
pub timestamp: std::option::Option<i64>,
89
+
/// The title of the track being scrobbled
90
+
#[serde(borrow)]
91
+
pub title: jacquard_common::CowStr<'a>,
92
+
/// The track number of the track in the album
93
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
94
+
pub track_number: std::option::Option<i64>,
95
+
/// The year the track was released
96
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
97
+
pub year: std::option::Option<i64>,
98
+
/// The Youtube link for the track, if available
99
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
100
+
#[serde(borrow)]
101
+
pub youtube_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,
102
+
}
103
+
104
+
#[jacquard_derive::lexicon]
105
+
#[derive(
106
+
serde::Serialize,
107
+
serde::Deserialize,
108
+
Debug,
109
+
Clone,
110
+
PartialEq,
111
+
Eq,
112
+
jacquard_derive::IntoStatic
113
+
)]
114
+
#[serde(rename_all = "camelCase")]
115
+
pub struct CreateScrobbleOutput<'a> {
116
+
#[serde(flatten)]
117
+
#[serde(borrow)]
118
+
pub value: crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>,
119
+
}
120
+
121
+
///Response type for
122
+
///app.rocksky.scrobble.createScrobble
123
+
pub struct CreateScrobbleResponse;
124
+
impl jacquard_common::xrpc::XrpcResp for CreateScrobbleResponse {
125
+
const NSID: &'static str = "app.rocksky.scrobble.createScrobble";
126
+
const ENCODING: &'static str = "application/json";
127
+
type Output<'de> = CreateScrobbleOutput<'de>;
128
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
129
+
}
130
+
131
+
impl<'a> jacquard_common::xrpc::XrpcRequest for CreateScrobble<'a> {
132
+
const NSID: &'static str = "app.rocksky.scrobble.createScrobble";
133
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
134
+
"application/json",
135
+
);
136
+
type Response = CreateScrobbleResponse;
137
+
}
138
+
139
+
///Endpoint type for
140
+
///app.rocksky.scrobble.createScrobble
141
+
pub struct CreateScrobbleRequest;
142
+
impl jacquard_common::xrpc::XrpcEndpoint for CreateScrobbleRequest {
143
+
const PATH: &'static str = "/xrpc/app.rocksky.scrobble.createScrobble";
144
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
145
+
"application/json",
146
+
);
147
+
type Request<'de> = CreateScrobble<'de>;
148
+
type Response = CreateScrobbleResponse;
149
+
}
+66
crates/jacquard-api/src/app_rocksky/scrobble/get_scrobble.rs
+66
crates/jacquard-api/src/app_rocksky/scrobble/get_scrobble.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.scrobble.getScrobble
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetScrobble<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetScrobbleOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::scrobble::ScrobbleViewDetailed<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.scrobble.getScrobble
44
+
pub struct GetScrobbleResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetScrobbleResponse {
46
+
const NSID: &'static str = "app.rocksky.scrobble.getScrobble";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetScrobbleOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobble<'a> {
53
+
const NSID: &'static str = "app.rocksky.scrobble.getScrobble";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetScrobbleResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.scrobble.getScrobble
60
+
pub struct GetScrobbleRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetScrobbleRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.scrobble.getScrobble";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetScrobble<'de>;
65
+
type Response = GetScrobbleResponse;
66
+
}
+76
crates/jacquard-api/src/app_rocksky/scrobble/get_scrobbles.rs
+76
crates/jacquard-api/src/app_rocksky/scrobble/get_scrobbles.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.scrobble.getScrobbles
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetScrobbles<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
24
+
///(min: 1)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub limit: std::option::Option<i64>,
27
+
///(min: 0)
28
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
29
+
pub offset: std::option::Option<i64>,
30
+
}
31
+
32
+
#[jacquard_derive::lexicon]
33
+
#[derive(
34
+
serde::Serialize,
35
+
serde::Deserialize,
36
+
Debug,
37
+
Clone,
38
+
PartialEq,
39
+
Eq,
40
+
jacquard_derive::IntoStatic,
41
+
Default
42
+
)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct GetScrobblesOutput<'a> {
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub scrobbles: std::option::Option<
48
+
Vec<crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>>,
49
+
>,
50
+
}
51
+
52
+
///Response type for
53
+
///app.rocksky.scrobble.getScrobbles
54
+
pub struct GetScrobblesResponse;
55
+
impl jacquard_common::xrpc::XrpcResp for GetScrobblesResponse {
56
+
const NSID: &'static str = "app.rocksky.scrobble.getScrobbles";
57
+
const ENCODING: &'static str = "application/json";
58
+
type Output<'de> = GetScrobblesOutput<'de>;
59
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
60
+
}
61
+
62
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobbles<'a> {
63
+
const NSID: &'static str = "app.rocksky.scrobble.getScrobbles";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Response = GetScrobblesResponse;
66
+
}
67
+
68
+
///Endpoint type for
69
+
///app.rocksky.scrobble.getScrobbles
70
+
pub struct GetScrobblesRequest;
71
+
impl jacquard_common::xrpc::XrpcEndpoint for GetScrobblesRequest {
72
+
const PATH: &'static str = "/xrpc/app.rocksky.scrobble.getScrobbles";
73
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
74
+
type Request<'de> = GetScrobbles<'de>;
75
+
type Response = GetScrobblesResponse;
76
+
}
+291
crates/jacquard-api/src/app_rocksky/scrobble.rs
+291
crates/jacquard-api/src/app_rocksky/scrobble.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.scrobble.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod create_scrobble;
9
+
pub mod get_scrobble;
10
+
pub mod get_scrobbles;
11
+
12
+
/// A declaration of a scrobble.
13
+
#[jacquard_derive::lexicon]
14
+
#[derive(
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
Debug,
18
+
Clone,
19
+
PartialEq,
20
+
Eq,
21
+
jacquard_derive::IntoStatic,
22
+
bon::Builder
23
+
)]
24
+
#[serde(rename_all = "camelCase")]
25
+
pub struct Scrobble<'a> {
26
+
/// The album of the song.
27
+
#[serde(borrow)]
28
+
#[builder(into)]
29
+
pub album: jacquard_common::CowStr<'a>,
30
+
/// The album art of the song.
31
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
32
+
#[builder(into)]
33
+
#[serde(borrow)]
34
+
pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,
35
+
/// The album artist of the song.
36
+
#[serde(borrow)]
37
+
#[builder(into)]
38
+
pub album_artist: jacquard_common::CowStr<'a>,
39
+
/// The Apple Music link of the song.
40
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
41
+
#[builder(into)]
42
+
#[serde(borrow)]
43
+
pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,
44
+
/// The artist of the song.
45
+
#[serde(borrow)]
46
+
#[builder(into)]
47
+
pub artist: jacquard_common::CowStr<'a>,
48
+
/// The composer of the song.
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[builder(into)]
51
+
#[serde(borrow)]
52
+
pub composer: Option<jacquard_common::CowStr<'a>>,
53
+
/// The copyright message of the song.
54
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
55
+
#[builder(into)]
56
+
#[serde(borrow)]
57
+
pub copyright_message: Option<jacquard_common::CowStr<'a>>,
58
+
/// The date when the song was created.
59
+
pub created_at: jacquard_common::types::string::Datetime,
60
+
/// The disc number of the song in the album.
61
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
62
+
#[builder(into)]
63
+
pub disc_number: Option<i64>,
64
+
/// The duration of the song in seconds.
65
+
pub duration: i64,
66
+
/// The genre of the song.
67
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
68
+
#[builder(into)]
69
+
#[serde(borrow)]
70
+
pub genre: Option<jacquard_common::CowStr<'a>>,
71
+
/// The label of the song.
72
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
73
+
#[builder(into)]
74
+
#[serde(borrow)]
75
+
pub label: Option<jacquard_common::CowStr<'a>>,
76
+
/// The lyrics of the song.
77
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
78
+
#[builder(into)]
79
+
#[serde(borrow)]
80
+
pub lyrics: Option<jacquard_common::CowStr<'a>>,
81
+
/// The MusicBrainz ID of the song.
82
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
83
+
#[builder(into)]
84
+
#[serde(borrow)]
85
+
pub mbid: Option<jacquard_common::CowStr<'a>>,
86
+
/// The release date of the song.
87
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
88
+
#[builder(into)]
89
+
pub release_date: Option<jacquard_common::types::string::Datetime>,
90
+
/// The Spotify link of the song.
91
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
92
+
#[builder(into)]
93
+
#[serde(borrow)]
94
+
pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,
95
+
/// The tags of the song.
96
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
97
+
#[builder(into)]
98
+
#[serde(borrow)]
99
+
pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
100
+
/// The Tidal link of the song.
101
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
102
+
#[builder(into)]
103
+
#[serde(borrow)]
104
+
pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,
105
+
/// The title of the song.
106
+
#[serde(borrow)]
107
+
#[builder(into)]
108
+
pub title: jacquard_common::CowStr<'a>,
109
+
/// The track number of the song in the album.
110
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
111
+
#[builder(into)]
112
+
pub track_number: Option<i64>,
113
+
/// Informations about the song
114
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
115
+
#[builder(into)]
116
+
#[serde(borrow)]
117
+
pub wiki: Option<jacquard_common::CowStr<'a>>,
118
+
/// The year the song was released.
119
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
120
+
#[builder(into)]
121
+
pub year: Option<i64>,
122
+
/// The YouTube link of the song.
123
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
124
+
#[builder(into)]
125
+
#[serde(borrow)]
126
+
pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,
127
+
}
128
+
129
+
/// Typed wrapper for GetRecord response with this collection's record type.
130
+
#[derive(
131
+
serde::Serialize,
132
+
serde::Deserialize,
133
+
Debug,
134
+
Clone,
135
+
PartialEq,
136
+
Eq,
137
+
jacquard_derive::IntoStatic
138
+
)]
139
+
#[serde(rename_all = "camelCase")]
140
+
pub struct ScrobbleGetRecordOutput<'a> {
141
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
142
+
#[serde(borrow)]
143
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
144
+
#[serde(borrow)]
145
+
pub uri: jacquard_common::types::string::AtUri<'a>,
146
+
#[serde(borrow)]
147
+
pub value: Scrobble<'a>,
148
+
}
149
+
150
+
/// Marker type for deserializing records from this collection.
151
+
pub struct ScrobbleRecord;
152
+
impl jacquard_common::xrpc::XrpcResp for ScrobbleRecord {
153
+
const NSID: &'static str = "app.rocksky.scrobble";
154
+
const ENCODING: &'static str = "application/json";
155
+
type Output<'de> = ScrobbleGetRecordOutput<'de>;
156
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
157
+
}
158
+
159
+
impl jacquard_common::types::collection::Collection for Scrobble<'_> {
160
+
const NSID: &'static str = "app.rocksky.scrobble";
161
+
type Record = ScrobbleRecord;
162
+
}
163
+
164
+
impl From<ScrobbleGetRecordOutput<'_>> for Scrobble<'_> {
165
+
fn from(output: ScrobbleGetRecordOutput<'_>) -> Self {
166
+
use jacquard_common::IntoStatic;
167
+
output.value.into_static()
168
+
}
169
+
}
170
+
171
+
#[jacquard_derive::lexicon]
172
+
#[derive(
173
+
serde::Serialize,
174
+
serde::Deserialize,
175
+
Debug,
176
+
Clone,
177
+
PartialEq,
178
+
Eq,
179
+
jacquard_derive::IntoStatic,
180
+
Default
181
+
)]
182
+
#[serde(rename_all = "camelCase")]
183
+
pub struct ScrobbleViewBasic<'a> {
184
+
/// The album of the song.
185
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
186
+
#[serde(borrow)]
187
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
188
+
/// The URI of the album.
189
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
190
+
#[serde(borrow)]
191
+
pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
192
+
/// The artist of the song.
193
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
194
+
#[serde(borrow)]
195
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
196
+
/// The URI of the artist.
197
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
198
+
#[serde(borrow)]
199
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
200
+
/// The album art URL of the song.
201
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
202
+
#[serde(borrow)]
203
+
pub cover: std::option::Option<jacquard_common::types::string::Uri<'a>>,
204
+
/// The timestamp when the scrobble was created.
205
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
206
+
pub date: std::option::Option<jacquard_common::types::string::Datetime>,
207
+
/// The unique identifier of the scrobble.
208
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
209
+
#[serde(borrow)]
210
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
211
+
/// The SHA256 hash of the scrobble data.
212
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
213
+
#[serde(borrow)]
214
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
215
+
/// The title of the scrobble.
216
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
217
+
#[serde(borrow)]
218
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
219
+
/// The URI of the scrobble.
220
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
221
+
#[serde(borrow)]
222
+
pub uri: std::option::Option<jacquard_common::types::string::Uri<'a>>,
223
+
/// The handle of the user who created the scrobble.
224
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
225
+
#[serde(borrow)]
226
+
pub user: std::option::Option<jacquard_common::CowStr<'a>>,
227
+
}
228
+
229
+
#[jacquard_derive::lexicon]
230
+
#[derive(
231
+
serde::Serialize,
232
+
serde::Deserialize,
233
+
Debug,
234
+
Clone,
235
+
PartialEq,
236
+
Eq,
237
+
jacquard_derive::IntoStatic,
238
+
Default
239
+
)]
240
+
#[serde(rename_all = "camelCase")]
241
+
pub struct ScrobbleViewDetailed<'a> {
242
+
/// The album of the song.
243
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
244
+
#[serde(borrow)]
245
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
246
+
/// The URI of the album.
247
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
248
+
#[serde(borrow)]
249
+
pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
250
+
/// The artist of the song.
251
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
252
+
#[serde(borrow)]
253
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
254
+
/// The URI of the artist.
255
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
256
+
#[serde(borrow)]
257
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
258
+
/// The album art URL of the song.
259
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
260
+
#[serde(borrow)]
261
+
pub cover: std::option::Option<jacquard_common::types::string::Uri<'a>>,
262
+
/// The timestamp when the scrobble was created.
263
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
264
+
pub date: std::option::Option<jacquard_common::types::string::Datetime>,
265
+
/// The unique identifier of the scrobble.
266
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
267
+
#[serde(borrow)]
268
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
269
+
/// The number of listeners
270
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
271
+
pub listeners: std::option::Option<i64>,
272
+
/// The number of scrobbles for this song
273
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
274
+
pub scrobbles: std::option::Option<i64>,
275
+
/// The SHA256 hash of the scrobble data.
276
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
277
+
#[serde(borrow)]
278
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
279
+
/// The title of the scrobble.
280
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
281
+
#[serde(borrow)]
282
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
283
+
/// The URI of the scrobble.
284
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
285
+
#[serde(borrow)]
286
+
pub uri: std::option::Option<jacquard_common::types::string::Uri<'a>>,
287
+
/// The handle of the user who created the scrobble.
288
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
289
+
#[serde(borrow)]
290
+
pub user: std::option::Option<jacquard_common::CowStr<'a>>,
291
+
}
+72
crates/jacquard-api/src/app_rocksky/shout/create_shout.rs
+72
crates/jacquard-api/src/app_rocksky/shout/create_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.createShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct CreateShout<'a> {
21
+
/// The content of the shout
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub message: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
}
26
+
27
+
#[jacquard_derive::lexicon]
28
+
#[derive(
29
+
serde::Serialize,
30
+
serde::Deserialize,
31
+
Debug,
32
+
Clone,
33
+
PartialEq,
34
+
Eq,
35
+
jacquard_derive::IntoStatic
36
+
)]
37
+
#[serde(rename_all = "camelCase")]
38
+
pub struct CreateShoutOutput<'a> {
39
+
#[serde(flatten)]
40
+
#[serde(borrow)]
41
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
42
+
}
43
+
44
+
///Response type for
45
+
///app.rocksky.shout.createShout
46
+
pub struct CreateShoutResponse;
47
+
impl jacquard_common::xrpc::XrpcResp for CreateShoutResponse {
48
+
const NSID: &'static str = "app.rocksky.shout.createShout";
49
+
const ENCODING: &'static str = "application/json";
50
+
type Output<'de> = CreateShoutOutput<'de>;
51
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52
+
}
53
+
54
+
impl<'a> jacquard_common::xrpc::XrpcRequest for CreateShout<'a> {
55
+
const NSID: &'static str = "app.rocksky.shout.createShout";
56
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
57
+
"application/json",
58
+
);
59
+
type Response = CreateShoutResponse;
60
+
}
61
+
62
+
///Endpoint type for
63
+
///app.rocksky.shout.createShout
64
+
pub struct CreateShoutRequest;
65
+
impl jacquard_common::xrpc::XrpcEndpoint for CreateShoutRequest {
66
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.createShout";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Request<'de> = CreateShout<'de>;
71
+
type Response = CreateShoutResponse;
72
+
}
+73
crates/jacquard-api/src/app_rocksky/shout/get_album_shouts.rs
+73
crates/jacquard-api/src/app_rocksky/shout/get_album_shouts.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.getAlbumShouts
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetAlbumShouts<'a> {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
#[serde(borrow)]
28
+
pub uri: jacquard_common::types::string::AtUri<'a>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetAlbumShoutsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.shout.getAlbumShouts
51
+
pub struct GetAlbumShoutsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetAlbumShoutsResponse {
53
+
const NSID: &'static str = "app.rocksky.shout.getAlbumShouts";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetAlbumShoutsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbumShouts<'a> {
60
+
const NSID: &'static str = "app.rocksky.shout.getAlbumShouts";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetAlbumShoutsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.shout.getAlbumShouts
67
+
pub struct GetAlbumShoutsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumShoutsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.getAlbumShouts";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetAlbumShouts<'de>;
72
+
type Response = GetAlbumShoutsResponse;
73
+
}
+73
crates/jacquard-api/src/app_rocksky/shout/get_artist_shouts.rs
+73
crates/jacquard-api/src/app_rocksky/shout/get_artist_shouts.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.getArtistShouts
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetArtistShouts<'a> {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
#[serde(borrow)]
28
+
pub uri: jacquard_common::types::string::AtUri<'a>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetArtistShoutsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.shout.getArtistShouts
51
+
pub struct GetArtistShoutsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetArtistShoutsResponse {
53
+
const NSID: &'static str = "app.rocksky.shout.getArtistShouts";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetArtistShoutsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistShouts<'a> {
60
+
const NSID: &'static str = "app.rocksky.shout.getArtistShouts";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetArtistShoutsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.shout.getArtistShouts
67
+
pub struct GetArtistShoutsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetArtistShoutsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.getArtistShouts";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetArtistShouts<'de>;
72
+
type Response = GetArtistShoutsResponse;
73
+
}
+73
crates/jacquard-api/src/app_rocksky/shout/get_profile_shouts.rs
+73
crates/jacquard-api/src/app_rocksky/shout/get_profile_shouts.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.getProfileShouts
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetProfileShouts<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
///(min: 1)
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub limit: std::option::Option<i64>,
26
+
///(min: 0)
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub offset: std::option::Option<i64>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetProfileShoutsOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.shout.getProfileShouts
51
+
pub struct GetProfileShoutsResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetProfileShoutsResponse {
53
+
const NSID: &'static str = "app.rocksky.shout.getProfileShouts";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetProfileShoutsOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetProfileShouts<'a> {
60
+
const NSID: &'static str = "app.rocksky.shout.getProfileShouts";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetProfileShoutsResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.shout.getProfileShouts
67
+
pub struct GetProfileShoutsRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetProfileShoutsRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.getProfileShouts";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetProfileShouts<'de>;
72
+
type Response = GetProfileShoutsResponse;
73
+
}
+73
crates/jacquard-api/src/app_rocksky/shout/get_shout_replies.rs
+73
crates/jacquard-api/src/app_rocksky/shout/get_shout_replies.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.getShoutReplies
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetShoutReplies<'a> {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
#[serde(borrow)]
28
+
pub uri: jacquard_common::types::string::AtUri<'a>,
29
+
}
30
+
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
Default
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct GetShoutRepliesOutput<'a> {
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
47
+
}
48
+
49
+
///Response type for
50
+
///app.rocksky.shout.getShoutReplies
51
+
pub struct GetShoutRepliesResponse;
52
+
impl jacquard_common::xrpc::XrpcResp for GetShoutRepliesResponse {
53
+
const NSID: &'static str = "app.rocksky.shout.getShoutReplies";
54
+
const ENCODING: &'static str = "application/json";
55
+
type Output<'de> = GetShoutRepliesOutput<'de>;
56
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
57
+
}
58
+
59
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetShoutReplies<'a> {
60
+
const NSID: &'static str = "app.rocksky.shout.getShoutReplies";
61
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
62
+
type Response = GetShoutRepliesResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.shout.getShoutReplies
67
+
pub struct GetShoutRepliesRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for GetShoutRepliesRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.getShoutReplies";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
71
+
type Request<'de> = GetShoutReplies<'de>;
72
+
type Response = GetShoutRepliesResponse;
73
+
}
+67
crates/jacquard-api/src/app_rocksky/shout/get_track_shouts.rs
+67
crates/jacquard-api/src/app_rocksky/shout/get_track_shouts.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.getTrackShouts
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetTrackShouts<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic,
34
+
Default
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetTrackShoutsOutput<'a> {
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
#[serde(borrow)]
40
+
pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.shout.getTrackShouts
45
+
pub struct GetTrackShoutsResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetTrackShoutsResponse {
47
+
const NSID: &'static str = "app.rocksky.shout.getTrackShouts";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetTrackShoutsOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetTrackShouts<'a> {
54
+
const NSID: &'static str = "app.rocksky.shout.getTrackShouts";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetTrackShoutsResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.shout.getTrackShouts
61
+
pub struct GetTrackShoutsRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetTrackShoutsRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.getTrackShouts";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetTrackShouts<'de>;
66
+
type Response = GetTrackShoutsResponse;
67
+
}
+83
crates/jacquard-api/src/app_rocksky/shout/remove_shout.rs
+83
crates/jacquard-api/src/app_rocksky/shout/remove_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.removeShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct RemoveShoutParams<'a> {
21
+
#[serde(borrow)]
22
+
#[builder(into)]
23
+
pub id: jacquard_common::CowStr<'a>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct RemoveShoutOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
41
+
}
42
+
43
+
/// XRPC request marker type
44
+
#[derive(
45
+
Debug,
46
+
Clone,
47
+
Copy,
48
+
PartialEq,
49
+
Eq,
50
+
serde::Serialize,
51
+
serde::Deserialize,
52
+
jacquard_derive::IntoStatic
53
+
)]
54
+
pub struct RemoveShout;
55
+
///Response type for
56
+
///app.rocksky.shout.removeShout
57
+
pub struct RemoveShoutResponse;
58
+
impl jacquard_common::xrpc::XrpcResp for RemoveShoutResponse {
59
+
const NSID: &'static str = "app.rocksky.shout.removeShout";
60
+
const ENCODING: &'static str = "application/json";
61
+
type Output<'de> = RemoveShoutOutput<'de>;
62
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
63
+
}
64
+
65
+
impl jacquard_common::xrpc::XrpcRequest for RemoveShout {
66
+
const NSID: &'static str = "app.rocksky.shout.removeShout";
67
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
68
+
"application/json",
69
+
);
70
+
type Response = RemoveShoutResponse;
71
+
}
72
+
73
+
///Endpoint type for
74
+
///app.rocksky.shout.removeShout
75
+
pub struct RemoveShoutRequest;
76
+
impl jacquard_common::xrpc::XrpcEndpoint for RemoveShoutRequest {
77
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.removeShout";
78
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
79
+
"application/json",
80
+
);
81
+
type Request<'de> = RemoveShout;
82
+
type Response = RemoveShoutResponse;
83
+
}
+74
crates/jacquard-api/src/app_rocksky/shout/reply_shout.rs
+74
crates/jacquard-api/src/app_rocksky/shout/reply_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.replyShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct ReplyShout<'a> {
21
+
/// The content of the reply
22
+
#[serde(borrow)]
23
+
pub message: jacquard_common::CowStr<'a>,
24
+
/// The unique identifier of the shout to reply to
25
+
#[serde(borrow)]
26
+
pub shout_id: jacquard_common::CowStr<'a>,
27
+
}
28
+
29
+
#[jacquard_derive::lexicon]
30
+
#[derive(
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
Debug,
34
+
Clone,
35
+
PartialEq,
36
+
Eq,
37
+
jacquard_derive::IntoStatic
38
+
)]
39
+
#[serde(rename_all = "camelCase")]
40
+
pub struct ReplyShoutOutput<'a> {
41
+
#[serde(flatten)]
42
+
#[serde(borrow)]
43
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
44
+
}
45
+
46
+
///Response type for
47
+
///app.rocksky.shout.replyShout
48
+
pub struct ReplyShoutResponse;
49
+
impl jacquard_common::xrpc::XrpcResp for ReplyShoutResponse {
50
+
const NSID: &'static str = "app.rocksky.shout.replyShout";
51
+
const ENCODING: &'static str = "application/json";
52
+
type Output<'de> = ReplyShoutOutput<'de>;
53
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
54
+
}
55
+
56
+
impl<'a> jacquard_common::xrpc::XrpcRequest for ReplyShout<'a> {
57
+
const NSID: &'static str = "app.rocksky.shout.replyShout";
58
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
59
+
"application/json",
60
+
);
61
+
type Response = ReplyShoutResponse;
62
+
}
63
+
64
+
///Endpoint type for
65
+
///app.rocksky.shout.replyShout
66
+
pub struct ReplyShoutRequest;
67
+
impl jacquard_common::xrpc::XrpcEndpoint for ReplyShoutRequest {
68
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.replyShout";
69
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
70
+
"application/json",
71
+
);
72
+
type Request<'de> = ReplyShout<'de>;
73
+
type Response = ReplyShoutResponse;
74
+
}
+75
crates/jacquard-api/src/app_rocksky/shout/report_shout.rs
+75
crates/jacquard-api/src/app_rocksky/shout/report_shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.reportShout
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct ReportShout<'a> {
21
+
/// The reason for reporting the shout
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
#[serde(borrow)]
24
+
pub reason: std::option::Option<jacquard_common::CowStr<'a>>,
25
+
/// The unique identifier of the shout to report
26
+
#[serde(borrow)]
27
+
pub shout_id: jacquard_common::CowStr<'a>,
28
+
}
29
+
30
+
#[jacquard_derive::lexicon]
31
+
#[derive(
32
+
serde::Serialize,
33
+
serde::Deserialize,
34
+
Debug,
35
+
Clone,
36
+
PartialEq,
37
+
Eq,
38
+
jacquard_derive::IntoStatic
39
+
)]
40
+
#[serde(rename_all = "camelCase")]
41
+
pub struct ReportShoutOutput<'a> {
42
+
#[serde(flatten)]
43
+
#[serde(borrow)]
44
+
pub value: crate::app_rocksky::shout::ShoutView<'a>,
45
+
}
46
+
47
+
///Response type for
48
+
///app.rocksky.shout.reportShout
49
+
pub struct ReportShoutResponse;
50
+
impl jacquard_common::xrpc::XrpcResp for ReportShoutResponse {
51
+
const NSID: &'static str = "app.rocksky.shout.reportShout";
52
+
const ENCODING: &'static str = "application/json";
53
+
type Output<'de> = ReportShoutOutput<'de>;
54
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
55
+
}
56
+
57
+
impl<'a> jacquard_common::xrpc::XrpcRequest for ReportShout<'a> {
58
+
const NSID: &'static str = "app.rocksky.shout.reportShout";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
60
+
"application/json",
61
+
);
62
+
type Response = ReportShoutResponse;
63
+
}
64
+
65
+
///Endpoint type for
66
+
///app.rocksky.shout.reportShout
67
+
pub struct ReportShoutRequest;
68
+
impl jacquard_common::xrpc::XrpcEndpoint for ReportShoutRequest {
69
+
const PATH: &'static str = "/xrpc/app.rocksky.shout.reportShout";
70
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
71
+
"application/json",
72
+
);
73
+
type Request<'de> = ReportShout<'de>;
74
+
type Response = ReportShoutResponse;
75
+
}
+155
crates/jacquard-api/src/app_rocksky/shout.rs
+155
crates/jacquard-api/src/app_rocksky/shout.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.shout.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod create_shout;
9
+
pub mod get_album_shouts;
10
+
pub mod get_artist_shouts;
11
+
pub mod get_profile_shouts;
12
+
pub mod get_shout_replies;
13
+
pub mod get_track_shouts;
14
+
pub mod remove_shout;
15
+
pub mod reply_shout;
16
+
pub mod report_shout;
17
+
18
+
/// A declaration of a shout.
19
+
#[jacquard_derive::lexicon]
20
+
#[derive(
21
+
serde::Serialize,
22
+
serde::Deserialize,
23
+
Debug,
24
+
Clone,
25
+
PartialEq,
26
+
Eq,
27
+
jacquard_derive::IntoStatic,
28
+
bon::Builder
29
+
)]
30
+
#[serde(rename_all = "camelCase")]
31
+
pub struct Shout<'a> {
32
+
/// The date when the shout was created.
33
+
pub created_at: jacquard_common::types::string::Datetime,
34
+
/// The message of the shout.
35
+
#[serde(borrow)]
36
+
#[builder(into)]
37
+
pub message: jacquard_common::CowStr<'a>,
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
#[builder(into)]
40
+
#[serde(borrow)]
41
+
pub parent: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
42
+
#[serde(borrow)]
43
+
pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
44
+
}
45
+
46
+
/// Typed wrapper for GetRecord response with this collection's record type.
47
+
#[derive(
48
+
serde::Serialize,
49
+
serde::Deserialize,
50
+
Debug,
51
+
Clone,
52
+
PartialEq,
53
+
Eq,
54
+
jacquard_derive::IntoStatic
55
+
)]
56
+
#[serde(rename_all = "camelCase")]
57
+
pub struct ShoutGetRecordOutput<'a> {
58
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
59
+
#[serde(borrow)]
60
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
61
+
#[serde(borrow)]
62
+
pub uri: jacquard_common::types::string::AtUri<'a>,
63
+
#[serde(borrow)]
64
+
pub value: Shout<'a>,
65
+
}
66
+
67
+
/// Marker type for deserializing records from this collection.
68
+
pub struct ShoutRecord;
69
+
impl jacquard_common::xrpc::XrpcResp for ShoutRecord {
70
+
const NSID: &'static str = "app.rocksky.shout";
71
+
const ENCODING: &'static str = "application/json";
72
+
type Output<'de> = ShoutGetRecordOutput<'de>;
73
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
74
+
}
75
+
76
+
impl jacquard_common::types::collection::Collection for Shout<'_> {
77
+
const NSID: &'static str = "app.rocksky.shout";
78
+
type Record = ShoutRecord;
79
+
}
80
+
81
+
impl From<ShoutGetRecordOutput<'_>> for Shout<'_> {
82
+
fn from(output: ShoutGetRecordOutput<'_>) -> Self {
83
+
use jacquard_common::IntoStatic;
84
+
output.value.into_static()
85
+
}
86
+
}
87
+
88
+
#[jacquard_derive::lexicon]
89
+
#[derive(
90
+
serde::Serialize,
91
+
serde::Deserialize,
92
+
Debug,
93
+
Clone,
94
+
PartialEq,
95
+
Eq,
96
+
jacquard_derive::IntoStatic,
97
+
Default
98
+
)]
99
+
#[serde(rename_all = "camelCase")]
100
+
pub struct Author<'a> {
101
+
/// The URL of the author's avatar image.
102
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
103
+
#[serde(borrow)]
104
+
pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
105
+
/// The decentralized identifier (DID) of the author.
106
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
107
+
#[serde(borrow)]
108
+
pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
109
+
/// The display name of the author.
110
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
111
+
#[serde(borrow)]
112
+
pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
113
+
/// The handle of the author.
114
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
115
+
#[serde(borrow)]
116
+
pub handle: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
117
+
/// The unique identifier of the author.
118
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
119
+
#[serde(borrow)]
120
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
121
+
}
122
+
123
+
#[jacquard_derive::lexicon]
124
+
#[derive(
125
+
serde::Serialize,
126
+
serde::Deserialize,
127
+
Debug,
128
+
Clone,
129
+
PartialEq,
130
+
Eq,
131
+
jacquard_derive::IntoStatic,
132
+
Default
133
+
)]
134
+
#[serde(rename_all = "camelCase")]
135
+
pub struct ShoutView<'a> {
136
+
/// The author of the shout.
137
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
138
+
#[serde(borrow)]
139
+
pub author: std::option::Option<crate::app_rocksky::shout::Author<'a>>,
140
+
/// The date and time when the shout was created.
141
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
142
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
143
+
/// The unique identifier of the shout.
144
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
145
+
#[serde(borrow)]
146
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
147
+
/// The content of the shout.
148
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
149
+
#[serde(borrow)]
150
+
pub message: std::option::Option<jacquard_common::CowStr<'a>>,
151
+
/// The ID of the parent shout if this is a reply, otherwise null.
152
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
153
+
#[serde(borrow)]
154
+
pub parent: std::option::Option<jacquard_common::CowStr<'a>>,
155
+
}
+108
crates/jacquard-api/src/app_rocksky/song/create_song.rs
+108
crates/jacquard-api/src/app_rocksky/song/create_song.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.song.createSong
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[jacquard_derive::lexicon]
9
+
#[derive(
10
+
serde::Serialize,
11
+
serde::Deserialize,
12
+
Debug,
13
+
Clone,
14
+
PartialEq,
15
+
Eq,
16
+
jacquard_derive::IntoStatic,
17
+
Default
18
+
)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct CreateSong<'a> {
21
+
/// The album of the song, if applicable
22
+
#[serde(borrow)]
23
+
pub album: jacquard_common::CowStr<'a>,
24
+
/// The URL of the album art for the song
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
#[serde(borrow)]
27
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
28
+
/// The album artist of the song, if different from the main artist
29
+
#[serde(borrow)]
30
+
pub album_artist: jacquard_common::CowStr<'a>,
31
+
/// The artist of the song
32
+
#[serde(borrow)]
33
+
pub artist: jacquard_common::CowStr<'a>,
34
+
/// The disc number of the song in the album, if applicable
35
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
36
+
pub disc_number: std::option::Option<i64>,
37
+
/// The duration of the song in seconds
38
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
+
pub duration: std::option::Option<i64>,
40
+
/// The lyrics of the song, if available
41
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
42
+
#[serde(borrow)]
43
+
pub lyrics: std::option::Option<jacquard_common::CowStr<'a>>,
44
+
/// The MusicBrainz ID of the song, if available
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[serde(borrow)]
47
+
pub mb_id: std::option::Option<jacquard_common::CowStr<'a>>,
48
+
/// The release date of the song, formatted as YYYY-MM-DD
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[serde(borrow)]
51
+
pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,
52
+
/// The title of the song
53
+
#[serde(borrow)]
54
+
pub title: jacquard_common::CowStr<'a>,
55
+
/// The track number of the song in the album, if applicable
56
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
57
+
pub track_number: std::option::Option<i64>,
58
+
/// The year the song was released
59
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
60
+
pub year: std::option::Option<i64>,
61
+
}
62
+
63
+
#[jacquard_derive::lexicon]
64
+
#[derive(
65
+
serde::Serialize,
66
+
serde::Deserialize,
67
+
Debug,
68
+
Clone,
69
+
PartialEq,
70
+
Eq,
71
+
jacquard_derive::IntoStatic
72
+
)]
73
+
#[serde(rename_all = "camelCase")]
74
+
pub struct CreateSongOutput<'a> {
75
+
#[serde(flatten)]
76
+
#[serde(borrow)]
77
+
pub value: crate::app_rocksky::song::SongViewDetailed<'a>,
78
+
}
79
+
80
+
///Response type for
81
+
///app.rocksky.song.createSong
82
+
pub struct CreateSongResponse;
83
+
impl jacquard_common::xrpc::XrpcResp for CreateSongResponse {
84
+
const NSID: &'static str = "app.rocksky.song.createSong";
85
+
const ENCODING: &'static str = "application/json";
86
+
type Output<'de> = CreateSongOutput<'de>;
87
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
88
+
}
89
+
90
+
impl<'a> jacquard_common::xrpc::XrpcRequest for CreateSong<'a> {
91
+
const NSID: &'static str = "app.rocksky.song.createSong";
92
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
93
+
"application/json",
94
+
);
95
+
type Response = CreateSongResponse;
96
+
}
97
+
98
+
///Endpoint type for
99
+
///app.rocksky.song.createSong
100
+
pub struct CreateSongRequest;
101
+
impl jacquard_common::xrpc::XrpcEndpoint for CreateSongRequest {
102
+
const PATH: &'static str = "/xrpc/app.rocksky.song.createSong";
103
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
104
+
"application/json",
105
+
);
106
+
type Request<'de> = CreateSong<'de>;
107
+
type Response = CreateSongResponse;
108
+
}
+66
crates/jacquard-api/src/app_rocksky/song/get_song.rs
+66
crates/jacquard-api/src/app_rocksky/song/get_song.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.song.getSong
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetSong<'a> {
21
+
#[serde(borrow)]
22
+
pub uri: jacquard_common::types::string::AtUri<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetSongOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::song::SongViewDetailed<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.song.getSong
44
+
pub struct GetSongResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetSongResponse {
46
+
const NSID: &'static str = "app.rocksky.song.getSong";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetSongOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetSong<'a> {
53
+
const NSID: &'static str = "app.rocksky.song.getSong";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetSongResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.song.getSong
60
+
pub struct GetSongRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetSongRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.song.getSong";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetSong<'de>;
65
+
type Response = GetSongResponse;
66
+
}
+71
crates/jacquard-api/src/app_rocksky/song/get_songs.rs
+71
crates/jacquard-api/src/app_rocksky/song/get_songs.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.song.getSongs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetSongs {
21
+
///(min: 1)
22
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
+
pub limit: std::option::Option<i64>,
24
+
///(min: 0)
25
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
+
pub offset: std::option::Option<i64>,
27
+
}
28
+
29
+
#[jacquard_derive::lexicon]
30
+
#[derive(
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
Debug,
34
+
Clone,
35
+
PartialEq,
36
+
Eq,
37
+
jacquard_derive::IntoStatic,
38
+
Default
39
+
)]
40
+
#[serde(rename_all = "camelCase")]
41
+
pub struct GetSongsOutput<'a> {
42
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
43
+
#[serde(borrow)]
44
+
pub songs: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,
45
+
}
46
+
47
+
///Response type for
48
+
///app.rocksky.song.getSongs
49
+
pub struct GetSongsResponse;
50
+
impl jacquard_common::xrpc::XrpcResp for GetSongsResponse {
51
+
const NSID: &'static str = "app.rocksky.song.getSongs";
52
+
const ENCODING: &'static str = "application/json";
53
+
type Output<'de> = GetSongsOutput<'de>;
54
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
55
+
}
56
+
57
+
impl jacquard_common::xrpc::XrpcRequest for GetSongs {
58
+
const NSID: &'static str = "app.rocksky.song.getSongs";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
60
+
type Response = GetSongsResponse;
61
+
}
62
+
63
+
///Endpoint type for
64
+
///app.rocksky.song.getSongs
65
+
pub struct GetSongsRequest;
66
+
impl jacquard_common::xrpc::XrpcEndpoint for GetSongsRequest {
67
+
const PATH: &'static str = "/xrpc/app.rocksky.song.getSongs";
68
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
69
+
type Request<'de> = GetSongs;
70
+
type Response = GetSongsResponse;
71
+
}
+315
crates/jacquard-api/src/app_rocksky/song.rs
+315
crates/jacquard-api/src/app_rocksky/song.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.song.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod create_song;
9
+
pub mod get_song;
10
+
pub mod get_songs;
11
+
12
+
/// A declaration of a song.
13
+
#[jacquard_derive::lexicon]
14
+
#[derive(
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
Debug,
18
+
Clone,
19
+
PartialEq,
20
+
Eq,
21
+
jacquard_derive::IntoStatic,
22
+
bon::Builder
23
+
)]
24
+
#[serde(rename_all = "camelCase")]
25
+
pub struct Song<'a> {
26
+
/// The album of the song.
27
+
#[serde(borrow)]
28
+
#[builder(into)]
29
+
pub album: jacquard_common::CowStr<'a>,
30
+
/// The album art of the song.
31
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
32
+
#[builder(into)]
33
+
#[serde(borrow)]
34
+
pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,
35
+
/// The album artist of the song.
36
+
#[serde(borrow)]
37
+
#[builder(into)]
38
+
pub album_artist: jacquard_common::CowStr<'a>,
39
+
/// The Apple Music link of the song.
40
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
41
+
#[builder(into)]
42
+
#[serde(borrow)]
43
+
pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,
44
+
/// The artist of the song.
45
+
#[serde(borrow)]
46
+
#[builder(into)]
47
+
pub artist: jacquard_common::CowStr<'a>,
48
+
/// The composer of the song.
49
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
50
+
#[builder(into)]
51
+
#[serde(borrow)]
52
+
pub composer: Option<jacquard_common::CowStr<'a>>,
53
+
/// The copyright message of the song.
54
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
55
+
#[builder(into)]
56
+
#[serde(borrow)]
57
+
pub copyright_message: Option<jacquard_common::CowStr<'a>>,
58
+
/// The date when the song was created.
59
+
pub created_at: jacquard_common::types::string::Datetime,
60
+
/// The disc number of the song in the album.
61
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
62
+
#[builder(into)]
63
+
pub disc_number: Option<i64>,
64
+
/// The duration of the song in seconds.
65
+
pub duration: i64,
66
+
/// The genre of the song.
67
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
68
+
#[builder(into)]
69
+
#[serde(borrow)]
70
+
pub genre: Option<jacquard_common::CowStr<'a>>,
71
+
/// The label of the song.
72
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
73
+
#[builder(into)]
74
+
#[serde(borrow)]
75
+
pub label: Option<jacquard_common::CowStr<'a>>,
76
+
/// The lyrics of the song.
77
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
78
+
#[builder(into)]
79
+
#[serde(borrow)]
80
+
pub lyrics: Option<jacquard_common::CowStr<'a>>,
81
+
/// The MusicBrainz ID of the song.
82
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
83
+
#[builder(into)]
84
+
#[serde(borrow)]
85
+
pub mbid: Option<jacquard_common::CowStr<'a>>,
86
+
/// The release date of the song.
87
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
88
+
#[builder(into)]
89
+
pub release_date: Option<jacquard_common::types::string::Datetime>,
90
+
/// The Spotify link of the song.
91
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
92
+
#[builder(into)]
93
+
#[serde(borrow)]
94
+
pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,
95
+
/// The tags of the song.
96
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
97
+
#[builder(into)]
98
+
#[serde(borrow)]
99
+
pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,
100
+
/// The Tidal link of the song.
101
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
102
+
#[builder(into)]
103
+
#[serde(borrow)]
104
+
pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,
105
+
/// The title of the song.
106
+
#[serde(borrow)]
107
+
#[builder(into)]
108
+
pub title: jacquard_common::CowStr<'a>,
109
+
/// The track number of the song in the album.
110
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
111
+
#[builder(into)]
112
+
pub track_number: Option<i64>,
113
+
/// Informations about the song
114
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
115
+
#[builder(into)]
116
+
#[serde(borrow)]
117
+
pub wiki: Option<jacquard_common::CowStr<'a>>,
118
+
/// The year the song was released.
119
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
120
+
#[builder(into)]
121
+
pub year: Option<i64>,
122
+
/// The YouTube link of the song.
123
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
124
+
#[builder(into)]
125
+
#[serde(borrow)]
126
+
pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,
127
+
}
128
+
129
+
/// Typed wrapper for GetRecord response with this collection's record type.
130
+
#[derive(
131
+
serde::Serialize,
132
+
serde::Deserialize,
133
+
Debug,
134
+
Clone,
135
+
PartialEq,
136
+
Eq,
137
+
jacquard_derive::IntoStatic
138
+
)]
139
+
#[serde(rename_all = "camelCase")]
140
+
pub struct SongGetRecordOutput<'a> {
141
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
142
+
#[serde(borrow)]
143
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
144
+
#[serde(borrow)]
145
+
pub uri: jacquard_common::types::string::AtUri<'a>,
146
+
#[serde(borrow)]
147
+
pub value: Song<'a>,
148
+
}
149
+
150
+
/// Marker type for deserializing records from this collection.
151
+
pub struct SongRecord;
152
+
impl jacquard_common::xrpc::XrpcResp for SongRecord {
153
+
const NSID: &'static str = "app.rocksky.song";
154
+
const ENCODING: &'static str = "application/json";
155
+
type Output<'de> = SongGetRecordOutput<'de>;
156
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
157
+
}
158
+
159
+
impl jacquard_common::types::collection::Collection for Song<'_> {
160
+
const NSID: &'static str = "app.rocksky.song";
161
+
type Record = SongRecord;
162
+
}
163
+
164
+
impl From<SongGetRecordOutput<'_>> for Song<'_> {
165
+
fn from(output: SongGetRecordOutput<'_>) -> Self {
166
+
use jacquard_common::IntoStatic;
167
+
output.value.into_static()
168
+
}
169
+
}
170
+
171
+
#[jacquard_derive::lexicon]
172
+
#[derive(
173
+
serde::Serialize,
174
+
serde::Deserialize,
175
+
Debug,
176
+
Clone,
177
+
PartialEq,
178
+
Eq,
179
+
jacquard_derive::IntoStatic,
180
+
Default
181
+
)]
182
+
#[serde(rename_all = "camelCase")]
183
+
pub struct SongViewBasic<'a> {
184
+
/// The album of the song.
185
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
186
+
#[serde(borrow)]
187
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
188
+
/// The URL of the album art image.
189
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
190
+
#[serde(borrow)]
191
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
192
+
/// The artist of the album the song belongs to.
193
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
194
+
#[serde(borrow)]
195
+
pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,
196
+
/// The URI of the album the song belongs to.
197
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
198
+
#[serde(borrow)]
199
+
pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
200
+
/// The artist of the song.
201
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
202
+
#[serde(borrow)]
203
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
204
+
/// The URI of the artist of the song.
205
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
206
+
#[serde(borrow)]
207
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
208
+
/// The timestamp when the song was created.
209
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
210
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
211
+
/// The disc number of the song in the album.
212
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
213
+
pub disc_number: std::option::Option<i64>,
214
+
/// The duration of the song in milliseconds.
215
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
216
+
pub duration: std::option::Option<i64>,
217
+
/// The unique identifier of the song.
218
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
219
+
#[serde(borrow)]
220
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
221
+
/// The number of times the song has been played.
222
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
223
+
pub play_count: std::option::Option<i64>,
224
+
/// The SHA256 hash of the song.
225
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
226
+
#[serde(borrow)]
227
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
228
+
/// The title of the song.
229
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
230
+
#[serde(borrow)]
231
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
232
+
/// The track number of the song in the album.
233
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
234
+
pub track_number: std::option::Option<i64>,
235
+
/// The number of unique listeners who have played the song.
236
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
237
+
pub unique_listeners: std::option::Option<i64>,
238
+
/// The URI of the song.
239
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
240
+
#[serde(borrow)]
241
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
242
+
}
243
+
244
+
#[jacquard_derive::lexicon]
245
+
#[derive(
246
+
serde::Serialize,
247
+
serde::Deserialize,
248
+
Debug,
249
+
Clone,
250
+
PartialEq,
251
+
Eq,
252
+
jacquard_derive::IntoStatic,
253
+
Default
254
+
)]
255
+
#[serde(rename_all = "camelCase")]
256
+
pub struct SongViewDetailed<'a> {
257
+
/// The album of the song.
258
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
259
+
#[serde(borrow)]
260
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
261
+
/// The URL of the album art image.
262
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
263
+
#[serde(borrow)]
264
+
pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,
265
+
/// The artist of the album the song belongs to.
266
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
267
+
#[serde(borrow)]
268
+
pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,
269
+
/// The URI of the album the song belongs to.
270
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
271
+
#[serde(borrow)]
272
+
pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
273
+
/// The artist of the song.
274
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
275
+
#[serde(borrow)]
276
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
277
+
/// The URI of the artist of the song.
278
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
279
+
#[serde(borrow)]
280
+
pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
281
+
/// The timestamp when the song was created.
282
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
283
+
pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
284
+
/// The disc number of the song in the album.
285
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
286
+
pub disc_number: std::option::Option<i64>,
287
+
/// The duration of the song in milliseconds.
288
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
289
+
pub duration: std::option::Option<i64>,
290
+
/// The unique identifier of the song.
291
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
292
+
#[serde(borrow)]
293
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
294
+
/// The number of times the song has been played.
295
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
296
+
pub play_count: std::option::Option<i64>,
297
+
/// The SHA256 hash of the song.
298
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
299
+
#[serde(borrow)]
300
+
pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,
301
+
/// The title of the song.
302
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
303
+
#[serde(borrow)]
304
+
pub title: std::option::Option<jacquard_common::CowStr<'a>>,
305
+
/// The track number of the song in the album.
306
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
307
+
pub track_number: std::option::Option<i64>,
308
+
/// The number of unique listeners who have played the song.
309
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
310
+
pub unique_listeners: std::option::Option<i64>,
311
+
/// The URI of the song.
312
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
313
+
#[serde(borrow)]
314
+
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
315
+
}
+67
crates/jacquard-api/src/app_rocksky/spotify/get_currently_playing.rs
+67
crates/jacquard-api/src/app_rocksky/spotify/get_currently_playing.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.getCurrentlyPlaying
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetCurrentlyPlaying<'a> {
21
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
+
#[serde(borrow)]
23
+
pub actor: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,
24
+
}
25
+
26
+
#[jacquard_derive::lexicon]
27
+
#[derive(
28
+
serde::Serialize,
29
+
serde::Deserialize,
30
+
Debug,
31
+
Clone,
32
+
PartialEq,
33
+
Eq,
34
+
jacquard_derive::IntoStatic
35
+
)]
36
+
#[serde(rename_all = "camelCase")]
37
+
pub struct GetCurrentlyPlayingOutput<'a> {
38
+
#[serde(flatten)]
39
+
#[serde(borrow)]
40
+
pub value: crate::app_rocksky::player::CurrentlyPlayingViewDetailed<'a>,
41
+
}
42
+
43
+
///Response type for
44
+
///app.rocksky.spotify.getCurrentlyPlaying
45
+
pub struct GetCurrentlyPlayingResponse;
46
+
impl jacquard_common::xrpc::XrpcResp for GetCurrentlyPlayingResponse {
47
+
const NSID: &'static str = "app.rocksky.spotify.getCurrentlyPlaying";
48
+
const ENCODING: &'static str = "application/json";
49
+
type Output<'de> = GetCurrentlyPlayingOutput<'de>;
50
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
51
+
}
52
+
53
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetCurrentlyPlaying<'a> {
54
+
const NSID: &'static str = "app.rocksky.spotify.getCurrentlyPlaying";
55
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
56
+
type Response = GetCurrentlyPlayingResponse;
57
+
}
58
+
59
+
///Endpoint type for
60
+
///app.rocksky.spotify.getCurrentlyPlaying
61
+
pub struct GetCurrentlyPlayingRequest;
62
+
impl jacquard_common::xrpc::XrpcEndpoint for GetCurrentlyPlayingRequest {
63
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.getCurrentlyPlaying";
64
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65
+
type Request<'de> = GetCurrentlyPlaying<'de>;
66
+
type Response = GetCurrentlyPlayingResponse;
67
+
}
+48
crates/jacquard-api/src/app_rocksky/spotify/next.rs
+48
crates/jacquard-api/src/app_rocksky/spotify/next.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.next
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Next;
20
+
///Response type for
21
+
///app.rocksky.spotify.next
22
+
pub struct NextResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for NextResponse {
24
+
const NSID: &'static str = "app.rocksky.spotify.next";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Next {
31
+
const NSID: &'static str = "app.rocksky.spotify.next";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = NextResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.spotify.next
40
+
pub struct NextRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for NextRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.next";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Next;
47
+
type Response = NextResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/spotify/pause.rs
+48
crates/jacquard-api/src/app_rocksky/spotify/pause.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.pause
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Pause;
20
+
///Response type for
21
+
///app.rocksky.spotify.pause
22
+
pub struct PauseResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PauseResponse {
24
+
const NSID: &'static str = "app.rocksky.spotify.pause";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Pause {
31
+
const NSID: &'static str = "app.rocksky.spotify.pause";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PauseResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.spotify.pause
40
+
pub struct PauseRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PauseRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.pause";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Pause;
47
+
type Response = PauseResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/spotify/play.rs
+48
crates/jacquard-api/src/app_rocksky/spotify/play.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.play
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Play;
20
+
///Response type for
21
+
///app.rocksky.spotify.play
22
+
pub struct PlayResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PlayResponse {
24
+
const NSID: &'static str = "app.rocksky.spotify.play";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Play {
31
+
const NSID: &'static str = "app.rocksky.spotify.play";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PlayResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.spotify.play
40
+
pub struct PlayRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PlayRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.play";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Play;
47
+
type Response = PlayResponse;
48
+
}
+48
crates/jacquard-api/src/app_rocksky/spotify/previous.rs
+48
crates/jacquard-api/src/app_rocksky/spotify/previous.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.previous
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// XRPC request marker type
9
+
#[derive(
10
+
Debug,
11
+
Clone,
12
+
Copy,
13
+
PartialEq,
14
+
Eq,
15
+
serde::Serialize,
16
+
serde::Deserialize,
17
+
jacquard_derive::IntoStatic
18
+
)]
19
+
pub struct Previous;
20
+
///Response type for
21
+
///app.rocksky.spotify.previous
22
+
pub struct PreviousResponse;
23
+
impl jacquard_common::xrpc::XrpcResp for PreviousResponse {
24
+
const NSID: &'static str = "app.rocksky.spotify.previous";
25
+
const ENCODING: &'static str = "application/json";
26
+
type Output<'de> = ();
27
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
28
+
}
29
+
30
+
impl jacquard_common::xrpc::XrpcRequest for Previous {
31
+
const NSID: &'static str = "app.rocksky.spotify.previous";
32
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
33
+
"application/json",
34
+
);
35
+
type Response = PreviousResponse;
36
+
}
37
+
38
+
///Endpoint type for
39
+
///app.rocksky.spotify.previous
40
+
pub struct PreviousRequest;
41
+
impl jacquard_common::xrpc::XrpcEndpoint for PreviousRequest {
42
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.previous";
43
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
44
+
"application/json",
45
+
);
46
+
type Request<'de> = Previous;
47
+
type Response = PreviousResponse;
48
+
}
+64
crates/jacquard-api/src/app_rocksky/spotify/seek.rs
+64
crates/jacquard-api/src/app_rocksky/spotify/seek.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.seek
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct SeekParams {
21
+
pub position: i64,
22
+
}
23
+
24
+
/// XRPC request marker type
25
+
#[derive(
26
+
Debug,
27
+
Clone,
28
+
Copy,
29
+
PartialEq,
30
+
Eq,
31
+
serde::Serialize,
32
+
serde::Deserialize,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
pub struct Seek;
36
+
///Response type for
37
+
///app.rocksky.spotify.seek
38
+
pub struct SeekResponse;
39
+
impl jacquard_common::xrpc::XrpcResp for SeekResponse {
40
+
const NSID: &'static str = "app.rocksky.spotify.seek";
41
+
const ENCODING: &'static str = "application/json";
42
+
type Output<'de> = ();
43
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
44
+
}
45
+
46
+
impl jacquard_common::xrpc::XrpcRequest for Seek {
47
+
const NSID: &'static str = "app.rocksky.spotify.seek";
48
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
49
+
"application/json",
50
+
);
51
+
type Response = SeekResponse;
52
+
}
53
+
54
+
///Endpoint type for
55
+
///app.rocksky.spotify.seek
56
+
pub struct SeekRequest;
57
+
impl jacquard_common::xrpc::XrpcEndpoint for SeekRequest {
58
+
const PATH: &'static str = "/xrpc/app.rocksky.spotify.seek";
59
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
60
+
"application/json",
61
+
);
62
+
type Request<'de> = Seek;
63
+
type Response = SeekResponse;
64
+
}
+51
crates/jacquard-api/src/app_rocksky/spotify.rs
+51
crates/jacquard-api/src/app_rocksky/spotify.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.spotify.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_currently_playing;
9
+
pub mod next;
10
+
pub mod pause;
11
+
pub mod play;
12
+
pub mod previous;
13
+
pub mod seek;
14
+
15
+
#[jacquard_derive::lexicon]
16
+
#[derive(
17
+
serde::Serialize,
18
+
serde::Deserialize,
19
+
Debug,
20
+
Clone,
21
+
PartialEq,
22
+
Eq,
23
+
jacquard_derive::IntoStatic,
24
+
Default
25
+
)]
26
+
#[serde(rename_all = "camelCase")]
27
+
pub struct SpotifyTrackView<'a> {
28
+
/// The name of the album.
29
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
30
+
#[serde(borrow)]
31
+
pub album: std::option::Option<jacquard_common::CowStr<'a>>,
32
+
/// The name of the artist.
33
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
34
+
#[serde(borrow)]
35
+
pub artist: std::option::Option<jacquard_common::CowStr<'a>>,
36
+
/// The duration of the track in milliseconds.
37
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
38
+
pub duration: std::option::Option<i64>,
39
+
/// The unique identifier of the Spotify track.
40
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
41
+
#[serde(borrow)]
42
+
pub id: std::option::Option<jacquard_common::CowStr<'a>>,
43
+
/// The name of the track.
44
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
45
+
#[serde(borrow)]
46
+
pub name: std::option::Option<jacquard_common::CowStr<'a>>,
47
+
/// A URL to a preview of the track.
48
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
49
+
#[serde(borrow)]
50
+
pub preview_url: std::option::Option<jacquard_common::CowStr<'a>>,
51
+
}
+66
crates/jacquard-api/src/app_rocksky/stats/get_stats.rs
+66
crates/jacquard-api/src/app_rocksky/stats/get_stats.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.stats.getStats
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
#[derive(
9
+
serde::Serialize,
10
+
serde::Deserialize,
11
+
Debug,
12
+
Clone,
13
+
PartialEq,
14
+
Eq,
15
+
bon::Builder,
16
+
jacquard_derive::IntoStatic
17
+
)]
18
+
#[builder(start_fn = new)]
19
+
#[serde(rename_all = "camelCase")]
20
+
pub struct GetStats<'a> {
21
+
#[serde(borrow)]
22
+
pub did: jacquard_common::types::ident::AtIdentifier<'a>,
23
+
}
24
+
25
+
#[jacquard_derive::lexicon]
26
+
#[derive(
27
+
serde::Serialize,
28
+
serde::Deserialize,
29
+
Debug,
30
+
Clone,
31
+
PartialEq,
32
+
Eq,
33
+
jacquard_derive::IntoStatic
34
+
)]
35
+
#[serde(rename_all = "camelCase")]
36
+
pub struct GetStatsOutput<'a> {
37
+
#[serde(flatten)]
38
+
#[serde(borrow)]
39
+
pub value: crate::app_rocksky::stats::StatsView<'a>,
40
+
}
41
+
42
+
///Response type for
43
+
///app.rocksky.stats.getStats
44
+
pub struct GetStatsResponse;
45
+
impl jacquard_common::xrpc::XrpcResp for GetStatsResponse {
46
+
const NSID: &'static str = "app.rocksky.stats.getStats";
47
+
const ENCODING: &'static str = "application/json";
48
+
type Output<'de> = GetStatsOutput<'de>;
49
+
type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
50
+
}
51
+
52
+
impl<'a> jacquard_common::xrpc::XrpcRequest for GetStats<'a> {
53
+
const NSID: &'static str = "app.rocksky.stats.getStats";
54
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
55
+
type Response = GetStatsResponse;
56
+
}
57
+
58
+
///Endpoint type for
59
+
///app.rocksky.stats.getStats
60
+
pub struct GetStatsRequest;
61
+
impl jacquard_common::xrpc::XrpcEndpoint for GetStatsRequest {
62
+
const PATH: &'static str = "/xrpc/app.rocksky.stats.getStats";
63
+
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
64
+
type Request<'de> = GetStats<'de>;
65
+
type Response = GetStatsResponse;
66
+
}
+38
crates/jacquard-api/src/app_rocksky/stats.rs
+38
crates/jacquard-api/src/app_rocksky/stats.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: app.rocksky.stats.defs
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
pub mod get_stats;
9
+
10
+
#[jacquard_derive::lexicon]
11
+
#[derive(
12
+
serde::Serialize,
13
+
serde::Deserialize,
14
+
Debug,
15
+
Clone,
16
+
PartialEq,
17
+
Eq,
18
+
jacquard_derive::IntoStatic,
19
+
Default
20
+
)]
21
+
#[serde(rename_all = "camelCase")]
22
+
pub struct StatsView<'a> {
23
+
/// The total number of unique albums scrobbled.
24
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
+
pub albums: std::option::Option<i64>,
26
+
/// The total number of unique artists scrobbled.
27
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
+
pub artists: std::option::Option<i64>,
29
+
/// The total number of tracks marked as loved.
30
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
31
+
pub loved_tracks: std::option::Option<i64>,
32
+
/// The total number of scrobbles.
33
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
34
+
pub scrobbles: std::option::Option<i64>,
35
+
/// The total number of unique tracks scrobbled.
36
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
37
+
pub tracks: std::option::Option<i64>,
38
+
}
+22
crates/jacquard-api/src/app_rocksky 2.rs
+22
crates/jacquard-api/src/app_rocksky 2.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// This file was automatically generated from Lexicon schemas.
4
+
// Any manual changes will be overwritten on the next regeneration.
5
+
6
+
pub mod actor;
7
+
pub mod album;
8
+
pub mod apikey;
9
+
pub mod artist;
10
+
pub mod charts;
11
+
pub mod dropbox;
12
+
pub mod feed;
13
+
pub mod googledrive;
14
+
pub mod like;
15
+
pub mod player;
16
+
pub mod playlist;
17
+
pub mod radio;
18
+
pub mod scrobble;
19
+
pub mod shout;
20
+
pub mod song;
21
+
pub mod spotify;
22
+
pub mod stats;
+22
crates/jacquard-api/src/app_rocksky.rs
+22
crates/jacquard-api/src/app_rocksky.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// This file was automatically generated from Lexicon schemas.
4
+
// Any manual changes will be overwritten on the next regeneration.
5
+
6
+
pub mod actor;
7
+
pub mod album;
8
+
pub mod apikey;
9
+
pub mod artist;
10
+
pub mod charts;
11
+
pub mod dropbox;
12
+
pub mod feed;
13
+
pub mod googledrive;
14
+
pub mod like;
15
+
pub mod player;
16
+
pub mod playlist;
17
+
pub mod radio;
18
+
pub mod scrobble;
19
+
pub mod shout;
20
+
pub mod song;
21
+
pub mod spotify;
22
+
pub mod stats;
+6
crates/jacquard-api/src/lib.rs
+6
crates/jacquard-api/src/lib.rs
···
12
#[cfg(feature = "app_ocho")]
13
pub mod app_ocho;
14
15
+
#[cfg(feature = "app_rocksky")]
16
+
pub mod app_rocksky;
17
+
18
#[cfg(feature = "beauty_cybernetic")]
19
pub mod beauty_cybernetic;
20
···
89
90
#[cfg(feature = "net_aftertheinter")]
91
pub mod net_aftertheinter;
92
+
93
+
#[cfg(feature = "net_altq")]
94
+
pub mod net_altq;
95
96
#[cfg(feature = "net_anisota")]
97
pub mod net_anisota;
+135
crates/jacquard-api/src/net_altq/aqfile.rs
+135
crates/jacquard-api/src/net_altq/aqfile.rs
···
···
1
+
// @generated by jacquard-lexicon. DO NOT EDIT.
2
+
//
3
+
// Lexicon: net.altq.aqfile
4
+
//
5
+
// This file was automatically generated from Lexicon schemas.
6
+
// Any manual changes will be overwritten on the next regeneration.
7
+
8
+
/// Cryptographic checksum for integrity verification.
9
+
#[jacquard_derive::lexicon]
10
+
#[derive(
11
+
serde::Serialize,
12
+
serde::Deserialize,
13
+
Debug,
14
+
Clone,
15
+
PartialEq,
16
+
Eq,
17
+
jacquard_derive::IntoStatic,
18
+
Default
19
+
)]
20
+
#[serde(rename_all = "camelCase")]
21
+
pub struct Checksum<'a> {
22
+
/// Hash algorithm name.
23
+
#[serde(borrow)]
24
+
pub algo: jacquard_common::CowStr<'a>,
25
+
/// Hex or base64 encoded digest produced by the algorithm.
26
+
#[serde(borrow)]
27
+
pub hash: jacquard_common::CowStr<'a>,
28
+
}
29
+
30
+
/// File metadata describing the uploaded blob.
31
+
#[jacquard_derive::lexicon]
32
+
#[derive(
33
+
serde::Serialize,
34
+
serde::Deserialize,
35
+
Debug,
36
+
Clone,
37
+
PartialEq,
38
+
Eq,
39
+
jacquard_derive::IntoStatic,
40
+
bon::Builder
41
+
)]
42
+
#[serde(rename_all = "camelCase")]
43
+
pub struct File<'a> {
44
+
/// MIME type, e.g. 'video/mp4'.
45
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
46
+
#[builder(into)]
47
+
#[serde(borrow)]
48
+
pub mime_type: Option<jacquard_common::CowStr<'a>>,
49
+
/// Client-side last-modified timestamp.
50
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
51
+
#[builder(into)]
52
+
pub modified_at: Option<jacquard_common::types::string::Datetime>,
53
+
/// User-visible filename.
54
+
#[serde(borrow)]
55
+
#[builder(into)]
56
+
pub name: jacquard_common::CowStr<'a>,
57
+
/// File size in bytes.
58
+
pub size: i64,
59
+
}
60
+
61
+
/// A record representing an uploaded file blob with metadata.
62
+
#[jacquard_derive::lexicon]
63
+
#[derive(
64
+
serde::Serialize,
65
+
serde::Deserialize,
66
+
Debug,
67
+
Clone,
68
+
PartialEq,
69
+
Eq,
70
+
jacquard_derive::IntoStatic,
71
+
bon::Builder
72
+
)]
73
+
#[serde(rename_all = "camelCase")]
74
+
pub struct Aqfile<'a> {
75
+
/// Handle or DID of the account to attribute this upload to.
76
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
77
+
#[builder(into)]
78
+
#[serde(borrow)]
79
+
pub attribution: Option<jacquard_common::types::ident::AtIdentifier<'a>>,
80
+
/// The uploaded blob reference. Note: Individual PDS instances may enforce lower size limits.
81
+
#[serde(borrow)]
82
+
pub blob: jacquard_common::types::blob::Blob<'a>,
83
+
/// Optional cryptographic checksum for integrity verification.
84
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
85
+
#[builder(into)]
86
+
#[serde(borrow)]
87
+
pub checksum: Option<crate::net_altq::aqfile::Checksum<'a>>,
88
+
/// Timestamp when this record was created.
89
+
pub created_at: jacquard_common::types::string::Datetime,
90
+
/// Metadata about the file.
91
+
#[serde(borrow)]
92
+
pub file: crate::net_altq::aqfile::File<'a>,
93
+
}
94
+
95
+
/// Typed wrapper for GetRecord response with this collection's record type.
96
+
#[derive(
97
+
serde::Serialize,
98
+
serde::Deserialize,
99
+
Debug,
100
+
Clone,
101
+
PartialEq,
102
+
Eq,
103
+
jacquard_derive::IntoStatic
104
+
)]
105
+
#[serde(rename_all = "camelCase")]
106
+
pub struct AqfileGetRecordOutput<'a> {
107
+
#[serde(skip_serializing_if = "std::option::Option::is_none")]
108
+
#[serde(borrow)]
109
+
pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
110
+
#[serde(borrow)]
111
+
pub uri: jacquard_common::types::string::AtUri<'a>,
112
+
#[serde(borrow)]
113
+
pub value: Aqfile<'a>,
114
+
}
115
+
116
+
/// Marker type for deserializing records from this collection.
117
+
pub struct AqfileRecord;
118
+
impl jacquard_common::xrpc::XrpcResp for AqfileRecord {
119
+
const NSID: &'static str = "net.altq.aqfile";
120
+
const ENCODING: &'static str = "application/json";
121
+
type Output<'de> = AqfileGetRecordOutput<'de>;
122
+
type Err<'de> = jacquard_common::types::collection::RecordError<'de>;
123
+
}
124
+
125
+
impl jacquard_common::types::collection::Collection for Aqfile<'_> {
126
+
const NSID: &'static str = "net.altq.aqfile";
127
+
type Record = AqfileRecord;
128
+
}
129
+
130
+
impl From<AqfileGetRecordOutput<'_>> for Aqfile<'_> {
131
+
fn from(output: AqfileGetRecordOutput<'_>) -> Self {
132
+
use jacquard_common::IntoStatic;
133
+
output.value.into_static()
134
+
}
135
+
}
+6
crates/jacquard-api/src/net_altq 2.rs
+6
crates/jacquard-api/src/net_altq 2.rs
+6
crates/jacquard-api/src/net_altq.rs
+6
crates/jacquard-api/src/net_altq.rs
+5
lexicons.kdl
+5
lexicons.kdl