comparing main and feat/rocksky-lexicon on zbrox.com/jacquard

crates/jacquard-api/Cargo.toml

···

       37
       37
        
       app_blebbit = []

     

       38
       38
        
       app_bsky = []

     

       39
       39
        
       app_ocho = []

     

       40
       40
       +
       app_rocksky = []

     

       40
       41
        
       beauty_cybernetic = []

     

       41
       42
        
       blog_pckt = []

     

       42
       43
        
       blue__2048 = []

     
···

       62
       63
        
       moe_karashiiro = []

     

       63
       64
        
       my_skylights = []

     

       64
       65
        
       net_aftertheinter = []

     

       66
       66
       +
       net_altq = []

     

       65
       67
        
       net_anisota = ["app_bsky"]

     

       66
       68
        
       net_bnewbold = []

     

       67
       69
        
       net_mmatt = []

+78

crates/jacquard-api/lexicons/app_rocksky_actor_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "profileViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "avatar": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The URL of the actor's avatar image.",

     

       11
       11
       +
                 "format": "uri"

     

       12
       12
       +
               },

     

       13
       13
       +
               "createdAt": {

     

       14
       14
       +
                 "type": "string",

     

       15
       15
       +
                 "description": "The date and time when the actor was created.",

     

       16
       16
       +
                 "format": "datetime"

     

       17
       17
       +
               },

     

       18
       18
       +
               "did": {

     

       19
       19
       +
                 "type": "string",

     

       20
       20
       +
                 "description": "The DID of the actor."

     

       21
       21
       +
               },

     

       22
       22
       +
               "displayName": {

     

       23
       23
       +
                 "type": "string",

     

       24
       24
       +
                 "description": "The display name of the actor."

     

       25
       25
       +
               },

     

       26
       26
       +
               "handle": {

     

       27
       27
       +
                 "type": "string",

     

       28
       28
       +
                 "description": "The handle of the actor."

     

       29
       29
       +
               },

     

       30
       30
       +
               "id": {

     

       31
       31
       +
                 "type": "string",

     

       32
       32
       +
                 "description": "The unique identifier of the actor."

     

       33
       33
       +
               },

     

       34
       34
       +
               "updatedAt": {

     

       35
       35
       +
                 "type": "string",

     

       36
       36
       +
                 "description": "The date and time when the actor was last updated.",

     

       37
       37
       +
                 "format": "datetime"

     

       38
       38
       +
               }

     

       39
       39
       +
             }

     

       40
       40
       +
           },

     

       41
       41
       +
           "profileViewDetailed": {

     

       42
       42
       +
             "type": "object",

     

       43
       43
       +
             "properties": {

     

       44
       44
       +
               "avatar": {

     

       45
       45
       +
                 "type": "string",

     

       46
       46
       +
                 "description": "The URL of the actor's avatar image.",

     

       47
       47
       +
                 "format": "uri"

     

       48
       48
       +
               },

     

       49
       49
       +
               "createdAt": {

     

       50
       50
       +
                 "type": "string",

     

       51
       51
       +
                 "description": "The date and time when the actor was created.",

     

       52
       52
       +
                 "format": "datetime"

     

       53
       53
       +
               },

     

       54
       54
       +
               "did": {

     

       55
       55
       +
                 "type": "string",

     

       56
       56
       +
                 "description": "The DID of the actor."

     

       57
       57
       +
               },

     

       58
       58
       +
               "displayName": {

     

       59
       59
       +
                 "type": "string",

     

       60
       60
       +
                 "description": "The display name of the actor."

     

       61
       61
       +
               },

     

       62
       62
       +
               "handle": {

     

       63
       63
       +
                 "type": "string",

     

       64
       64
       +
                 "description": "The handle of the actor."

     

       65
       65
       +
               },

     

       66
       66
       +
               "id": {

     

       67
       67
       +
                 "type": "string",

     

       68
       68
       +
                 "description": "The unique identifier of the actor."

     

       69
       69
       +
               },

     

       70
       70
       +
               "updatedAt": {

     

       71
       71
       +
                 "type": "string",

     

       72
       72
       +
                 "description": "The date and time when the actor was last updated.",

     

       73
       73
       +
                 "format": "datetime"

     

       74
       74
       +
               }

     

       75
       75
       +
             }

     

       76
       76
       +
           }

     

       77
       77
       +
         }

     

       78
       78
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorAlbums.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorAlbums",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get albums for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "albums": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.album.defs#albumViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorArtists.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorArtists",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artists for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "artists": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.artist.defs#artistViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorLovedSongs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorLovedSongs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get loved songs for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "tracks": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.song.defs#songViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorPlaylists.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorPlaylists",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get playlists for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "playlists": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.playlist.defs#playlistViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorScrobbles.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorScrobbles",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get scrobbles for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "scrobbles": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_actor_getActorSongs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getActorSongs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get songs for an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of albums to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "songs": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.song.defs#songViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+27

crates/jacquard-api/lexicons/app_rocksky_actor_getProfile.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.actor.getProfile",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get the profile of an actor",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "did": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "The DID or handle of the actor",

     

       14
       14
       +
                   "format": "at-identifier"

     

       15
       15
       +
                 }

     

       16
       16
       +
               }

     

       17
       17
       +
             },

     

       18
       18
       +
             "output": {

     

       19
       19
       +
               "encoding": "application/json",

     

       20
       20
       +
               "schema": {

     

       21
       21
       +
                 "type": "ref",

     

       22
       22
       +
                 "ref": "app.rocksky.actor.defs#profileViewDetailed"

     

       23
       23
       +
               }

     

       24
       24
       +
             }

     

       25
       25
       +
           }

     

       26
       26
       +
         }

     

       27
       27
       +
       }

+94

crates/jacquard-api/lexicons/app_rocksky_album.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.album",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of an album.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "title",

     

       13
       13
       +
                 "artist",

     

       14
       14
       +
                 "createdAt"

     

       15
       15
       +
               ],

     

       16
       16
       +
               "properties": {

     

       17
       17
       +
                 "albumArt": {

     

       18
       18
       +
                   "type": "blob",

     

       19
       19
       +
                   "description": "The album art of the album.",

     

       20
       20
       +
                   "accept": [

     

       21
       21
       +
                     "image/png",

     

       22
       22
       +
                     "image/jpeg"

     

       23
       23
       +
                   ],

     

       24
       24
       +
                   "maxSize": 2000000

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "appleMusicLink": {

     

       27
       27
       +
                   "type": "string",

     

       28
       28
       +
                   "description": "The Apple Music link of the album.",

     

       29
       29
       +
                   "format": "uri"

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "artist": {

     

       32
       32
       +
                   "type": "string",

     

       33
       33
       +
                   "description": "The artist of the album.",

     

       34
       34
       +
                   "minLength": 1,

     

       35
       35
       +
                   "maxLength": 256

     

       36
       36
       +
                 },

     

       37
       37
       +
                 "createdAt": {

     

       38
       38
       +
                   "type": "string",

     

       39
       39
       +
                   "description": "The date and time when the album was created.",

     

       40
       40
       +
                   "format": "datetime"

     

       41
       41
       +
                 },

     

       42
       42
       +
                 "duration": {

     

       43
       43
       +
                   "type": "integer",

     

       44
       44
       +
                   "description": "The duration of the album in seconds."

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "genre": {

     

       47
       47
       +
                   "type": "string",

     

       48
       48
       +
                   "description": "The genre of the album.",

     

       49
       49
       +
                   "maxLength": 256

     

       50
       50
       +
                 },

     

       51
       51
       +
                 "releaseDate": {

     

       52
       52
       +
                   "type": "string",

     

       53
       53
       +
                   "description": "The release date of the album.",

     

       54
       54
       +
                   "format": "datetime"

     

       55
       55
       +
                 },

     

       56
       56
       +
                 "spotifyLink": {

     

       57
       57
       +
                   "type": "string",

     

       58
       58
       +
                   "description": "The Spotify link of the album.",

     

       59
       59
       +
                   "format": "uri"

     

       60
       60
       +
                 },

     

       61
       61
       +
                 "tags": {

     

       62
       62
       +
                   "type": "array",

     

       63
       63
       +
                   "description": "The tags of the album.",

     

       64
       64
       +
                   "items": {

     

       65
       65
       +
                     "type": "string",

     

       66
       66
       +
                     "minLength": 1,

     

       67
       67
       +
                     "maxLength": 256

     

       68
       68
       +
                   }

     

       69
       69
       +
                 },

     

       70
       70
       +
                 "tidalLink": {

     

       71
       71
       +
                   "type": "string",

     

       72
       72
       +
                   "description": "The tidal link of the album.",

     

       73
       73
       +
                   "format": "uri"

     

       74
       74
       +
                 },

     

       75
       75
       +
                 "title": {

     

       76
       76
       +
                   "type": "string",

     

       77
       77
       +
                   "description": "The title of the album.",

     

       78
       78
       +
                   "minLength": 1,

     

       79
       79
       +
                   "maxLength": 512

     

       80
       80
       +
                 },

     

       81
       81
       +
                 "year": {

     

       82
       82
       +
                   "type": "integer",

     

       83
       83
       +
                   "description": "The year the album was released."

     

       84
       84
       +
                 },

     

       85
       85
       +
                 "youtubeLink": {

     

       86
       86
       +
                   "type": "string",

     

       87
       87
       +
                   "description": "The YouTube link of the album.",

     

       88
       88
       +
                   "format": "uri"

     

       89
       89
       +
                 }

     

       90
       90
       +
               }

     

       91
       91
       +
             }

     

       92
       92
       +
           }

     

       93
       93
       +
         }

     

       94
       94
       +
       }

+121

crates/jacquard-api/lexicons/app_rocksky_album_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.album.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "albumViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "albumArt": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The URL of the album art image.",

     

       11
       11
       +
                 "format": "uri"

     

       12
       12
       +
               },

     

       13
       13
       +
               "artist": {

     

       14
       14
       +
                 "type": "string",

     

       15
       15
       +
                 "description": "The artist of the album."

     

       16
       16
       +
               },

     

       17
       17
       +
               "artistUri": {

     

       18
       18
       +
                 "type": "string",

     

       19
       19
       +
                 "description": "The URI of the album's artist.",

     

       20
       20
       +
                 "format": "at-uri"

     

       21
       21
       +
               },

     

       22
       22
       +
               "id": {

     

       23
       23
       +
                 "type": "string",

     

       24
       24
       +
                 "description": "The unique identifier of the album."

     

       25
       25
       +
               },

     

       26
       26
       +
               "playCount": {

     

       27
       27
       +
                 "type": "integer",

     

       28
       28
       +
                 "description": "The number of times the album has been played.",

     

       29
       29
       +
                 "minimum": 0

     

       30
       30
       +
               },

     

       31
       31
       +
               "releaseDate": {

     

       32
       32
       +
                 "type": "string",

     

       33
       33
       +
                 "description": "The release date of the album."

     

       34
       34
       +
               },

     

       35
       35
       +
               "sha256": {

     

       36
       36
       +
                 "type": "string",

     

       37
       37
       +
                 "description": "The SHA256 hash of the album."

     

       38
       38
       +
               },

     

       39
       39
       +
               "title": {

     

       40
       40
       +
                 "type": "string",

     

       41
       41
       +
                 "description": "The title of the album."

     

       42
       42
       +
               },

     

       43
       43
       +
               "uniqueListeners": {

     

       44
       44
       +
                 "type": "integer",

     

       45
       45
       +
                 "description": "The number of unique listeners who have played the album.",

     

       46
       46
       +
                 "minimum": 0

     

       47
       47
       +
               },

     

       48
       48
       +
               "uri": {

     

       49
       49
       +
                 "type": "string",

     

       50
       50
       +
                 "description": "The URI of the album.",

     

       51
       51
       +
                 "format": "at-uri"

     

       52
       52
       +
               },

     

       53
       53
       +
               "year": {

     

       54
       54
       +
                 "type": "integer",

     

       55
       55
       +
                 "description": "The year the album was released."

     

       56
       56
       +
               }

     

       57
       57
       +
             }

     

       58
       58
       +
           },

     

       59
       59
       +
           "albumViewDetailed": {

     

       60
       60
       +
             "type": "object",

     

       61
       61
       +
             "properties": {

     

       62
       62
       +
               "albumArt": {

     

       63
       63
       +
                 "type": "string",

     

       64
       64
       +
                 "description": "The URL of the album art image.",

     

       65
       65
       +
                 "format": "uri"

     

       66
       66
       +
               },

     

       67
       67
       +
               "artist": {

     

       68
       68
       +
                 "type": "string",

     

       69
       69
       +
                 "description": "The artist of the album."

     

       70
       70
       +
               },

     

       71
       71
       +
               "artistUri": {

     

       72
       72
       +
                 "type": "string",

     

       73
       73
       +
                 "description": "The URI of the album's artist.",

     

       74
       74
       +
                 "format": "at-uri"

     

       75
       75
       +
               },

     

       76
       76
       +
               "id": {

     

       77
       77
       +
                 "type": "string",

     

       78
       78
       +
                 "description": "The unique identifier of the album."

     

       79
       79
       +
               },

     

       80
       80
       +
               "playCount": {

     

       81
       81
       +
                 "type": "integer",

     

       82
       82
       +
                 "description": "The number of times the album has been played.",

     

       83
       83
       +
                 "minimum": 0

     

       84
       84
       +
               },

     

       85
       85
       +
               "releaseDate": {

     

       86
       86
       +
                 "type": "string",

     

       87
       87
       +
                 "description": "The release date of the album."

     

       88
       88
       +
               },

     

       89
       89
       +
               "sha256": {

     

       90
       90
       +
                 "type": "string",

     

       91
       91
       +
                 "description": "The SHA256 hash of the album."

     

       92
       92
       +
               },

     

       93
       93
       +
               "title": {

     

       94
       94
       +
                 "type": "string",

     

       95
       95
       +
                 "description": "The title of the album."

     

       96
       96
       +
               },

     

       97
       97
       +
               "tracks": {

     

       98
       98
       +
                 "type": "array",

     

       99
       99
       +
                 "items": {

     

       100
       100
       +
                   "type": "ref",

     

       101
       101
       +
                   "ref": "app.rocksky.song.defs.songViewBasic"

     

       102
       102
       +
                 }

     

       103
       103
       +
               },

     

       104
       104
       +
               "uniqueListeners": {

     

       105
       105
       +
                 "type": "integer",

     

       106
       106
       +
                 "description": "The number of unique listeners who have played the album.",

     

       107
       107
       +
                 "minimum": 0

     

       108
       108
       +
               },

     

       109
       109
       +
               "uri": {

     

       110
       110
       +
                 "type": "string",

     

       111
       111
       +
                 "description": "The URI of the album.",

     

       112
       112
       +
                 "format": "at-uri"

     

       113
       113
       +
               },

     

       114
       114
       +
               "year": {

     

       115
       115
       +
                 "type": "integer",

     

       116
       116
       +
                 "description": "The year the album was released."

     

       117
       117
       +
               }

     

       118
       118
       +
             }

     

       119
       119
       +
           }

     

       120
       120
       +
         }

     

       121
       121
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_album_getAlbum.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.album.getAlbum",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get detailed album view",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the album to retrieve.",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.album.defs#albumViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_album_getAlbumTracks.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.album.getAlbumTracks",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get tracks for an album",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the album to retrieve tracks from",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "tracks": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.song.defs#songViewBasic"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+40

crates/jacquard-api/lexicons/app_rocksky_album_getAlbums.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.album.getAlbums",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get albums",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of albums to return",

     

       14
       14
       +
                   "minimum": 1

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "offset": {

     

       17
       17
       +
                   "type": "integer",

     

       18
       18
       +
                   "description": "The offset for pagination",

     

       19
       19
       +
                   "minimum": 0

     

       20
       20
       +
                 }

     

       21
       21
       +
               }

     

       22
       22
       +
             },

     

       23
       23
       +
             "output": {

     

       24
       24
       +
               "encoding": "application/json",

     

       25
       25
       +
               "schema": {

     

       26
       26
       +
                 "type": "object",

     

       27
       27
       +
                 "properties": {

     

       28
       28
       +
                   "albums": {

     

       29
       29
       +
                     "type": "array",

     

       30
       30
       +
                     "items": {

     

       31
       31
       +
                       "type": "ref",

     

       32
       32
       +
                       "ref": "app.rocksky.album.defs#albumViewBasic"

     

       33
       33
       +
                     }

     

       34
       34
       +
                   }

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             }

     

       38
       38
       +
           }

     

       39
       39
       +
         }

     

       40
       40
       +
       }

+36

crates/jacquard-api/lexicons/app_rocksky_apikey_createApikey.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikey.createApikey",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Create a new API key for the authenticated user",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "name"

     

       14
       14
       +
                 ],

     

       15
       15
       +
                 "properties": {

     

       16
       16
       +
                   "description": {

     

       17
       17
       +
                     "type": "string",

     

       18
       18
       +
                     "description": "A description for the API key."

     

       19
       19
       +
                   },

     

       20
       20
       +
                   "name": {

     

       21
       21
       +
                     "type": "string",

     

       22
       22
       +
                     "description": "The name of the API key."

     

       23
       23
       +
                   }

     

       24
       24
       +
                 }

     

       25
       25
       +
               }

     

       26
       26
       +
             },

     

       27
       27
       +
             "output": {

     

       28
       28
       +
               "encoding": "application/json",

     

       29
       29
       +
               "schema": {

     

       30
       30
       +
                 "type": "ref",

     

       31
       31
       +
                 "ref": "app.rocksky.apikey.defs#apiKey"

     

       32
       32
       +
               }

     

       33
       33
       +
             }

     

       34
       34
       +
           }

     

       35
       35
       +
         }

     

       36
       36
       +
       }

+28

crates/jacquard-api/lexicons/app_rocksky_apikey_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikey.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "apiKeyView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "createdAt": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The date and time when the API key was created.",

     

       11
       11
       +
                 "format": "datetime"

     

       12
       12
       +
               },

     

       13
       13
       +
               "description": {

     

       14
       14
       +
                 "type": "string",

     

       15
       15
       +
                 "description": "A description for the API key."

     

       16
       16
       +
               },

     

       17
       17
       +
               "id": {

     

       18
       18
       +
                 "type": "string",

     

       19
       19
       +
                 "description": "The unique identifier of the API key."

     

       20
       20
       +
               },

     

       21
       21
       +
               "name": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "The name of the API key."

     

       24
       24
       +
               }

     

       25
       25
       +
             }

     

       26
       26
       +
           }

     

       27
       27
       +
         }

     

       28
       28
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_apikey_getApikeys.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikey.getApikeys",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a list of API keys for the authenticated user",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The number of API keys to return per page."

     

       14
       14
       +
                 },

     

       15
       15
       +
                 "offset": {

     

       16
       16
       +
                   "type": "integer",

     

       17
       17
       +
                   "description": "The number of API keys to skip before starting to collect the result set."

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "apiKeys": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.apikey.defs#apikeyView"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_apikey_removeApikey.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikey.removeApikey",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Remove an API key for the authenticated user",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "id"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "id": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The ID of the API key to remove."

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.apikey.defs#apiKey"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+41

crates/jacquard-api/lexicons/app_rocksky_apikey_updateApikey.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikey.updateApikey",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Update an existing API key for the authenticated user",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "id",

     

       14
       14
       +
                   "name"

     

       15
       15
       +
                 ],

     

       16
       16
       +
                 "properties": {

     

       17
       17
       +
                   "description": {

     

       18
       18
       +
                     "type": "string",

     

       19
       19
       +
                     "description": "A new description for the API key."

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "id": {

     

       22
       22
       +
                     "type": "string",

     

       23
       23
       +
                     "description": "The ID of the API key to update."

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "name": {

     

       26
       26
       +
                     "type": "string",

     

       27
       27
       +
                     "description": "The new name of the API key."

     

       28
       28
       +
                   }

     

       29
       29
       +
                 }

     

       30
       30
       +
               }

     

       31
       31
       +
             },

     

       32
       32
       +
             "output": {

     

       33
       33
       +
               "encoding": "application/json",

     

       34
       34
       +
               "schema": {

     

       35
       35
       +
                 "type": "ref",

     

       36
       36
       +
                 "ref": "app.rocksky.apikey.defs#apiKey"

     

       37
       37
       +
               }

     

       38
       38
       +
             }

     

       39
       39
       +
           }

     

       40
       40
       +
         }

     

       41
       41
       +
       }

crates/jacquard-api/lexicons/app_rocksky_apikeys_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.apikeys.defs",

     

       4
       4
       +
         "defs": {}

     

       5
       5
       +
       }

+69

crates/jacquard-api/lexicons/app_rocksky_artist.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of an artist.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "name",

     

       13
       13
       +
                 "createdAt"

     

       14
       14
       +
               ],

     

       15
       15
       +
               "properties": {

     

       16
       16
       +
                 "bio": {

     

       17
       17
       +
                   "type": "string",

     

       18
       18
       +
                   "description": "The biography of the artist.",

     

       19
       19
       +
                   "maxLength": 1000

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "born": {

     

       22
       22
       +
                   "type": "string",

     

       23
       23
       +
                   "description": "The birth date of the artist.",

     

       24
       24
       +
                   "format": "datetime"

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "bornIn": {

     

       27
       27
       +
                   "type": "string",

     

       28
       28
       +
                   "description": "The birth place of the artist.",

     

       29
       29
       +
                   "maxLength": 256

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "createdAt": {

     

       32
       32
       +
                   "type": "string",

     

       33
       33
       +
                   "description": "The date when the artist was created.",

     

       34
       34
       +
                   "format": "datetime"

     

       35
       35
       +
                 },

     

       36
       36
       +
                 "died": {

     

       37
       37
       +
                   "type": "string",

     

       38
       38
       +
                   "description": "The death date of the artist.",

     

       39
       39
       +
                   "format": "datetime"

     

       40
       40
       +
                 },

     

       41
       41
       +
                 "name": {

     

       42
       42
       +
                   "type": "string",

     

       43
       43
       +
                   "description": "The name of the artist.",

     

       44
       44
       +
                   "minLength": 1,

     

       45
       45
       +
                   "maxLength": 512

     

       46
       46
       +
                 },

     

       47
       47
       +
                 "picture": {

     

       48
       48
       +
                   "type": "blob",

     

       49
       49
       +
                   "description": "The picture of the artist.",

     

       50
       50
       +
                   "accept": [

     

       51
       51
       +
                     "image/png",

     

       52
       52
       +
                     "image/jpeg"

     

       53
       53
       +
                   ],

     

       54
       54
       +
                   "maxSize": 2000000

     

       55
       55
       +
                 },

     

       56
       56
       +
                 "tags": {

     

       57
       57
       +
                   "type": "array",

     

       58
       58
       +
                   "description": "The tags of the artist.",

     

       59
       59
       +
                   "items": {

     

       60
       60
       +
                     "type": "string",

     

       61
       61
       +
                     "minLength": 1,

     

       62
       62
       +
                     "maxLength": 256

     

       63
       63
       +
                   }

     

       64
       64
       +
                 }

     

       65
       65
       +
               }

     

       66
       66
       +
             }

     

       67
       67
       +
           }

     

       68
       68
       +
         }

     

       69
       69
       +
       }

+78

crates/jacquard-api/lexicons/app_rocksky_artist_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "artistViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "id": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The unique identifier of the artist."

     

       11
       11
       +
               },

     

       12
       12
       +
               "name": {

     

       13
       13
       +
                 "type": "string",

     

       14
       14
       +
                 "description": "The name of the artist."

     

       15
       15
       +
               },

     

       16
       16
       +
               "picture": {

     

       17
       17
       +
                 "type": "string",

     

       18
       18
       +
                 "description": "The picture of the artist."

     

       19
       19
       +
               },

     

       20
       20
       +
               "playCount": {

     

       21
       21
       +
                 "type": "integer",

     

       22
       22
       +
                 "description": "The number of times the artist has been played.",

     

       23
       23
       +
                 "minimum": 0

     

       24
       24
       +
               },

     

       25
       25
       +
               "sha256": {

     

       26
       26
       +
                 "type": "string",

     

       27
       27
       +
                 "description": "The SHA256 hash of the artist."

     

       28
       28
       +
               },

     

       29
       29
       +
               "uniqueListeners": {

     

       30
       30
       +
                 "type": "integer",

     

       31
       31
       +
                 "description": "The number of unique listeners who have played the artist.",

     

       32
       32
       +
                 "minimum": 0

     

       33
       33
       +
               },

     

       34
       34
       +
               "uri": {

     

       35
       35
       +
                 "type": "string",

     

       36
       36
       +
                 "description": "The URI of the artist.",

     

       37
       37
       +
                 "format": "at-uri"

     

       38
       38
       +
               }

     

       39
       39
       +
             }

     

       40
       40
       +
           },

     

       41
       41
       +
           "artistViewDetailed": {

     

       42
       42
       +
             "type": "object",

     

       43
       43
       +
             "properties": {

     

       44
       44
       +
               "id": {

     

       45
       45
       +
                 "type": "string",

     

       46
       46
       +
                 "description": "The unique identifier of the artist."

     

       47
       47
       +
               },

     

       48
       48
       +
               "name": {

     

       49
       49
       +
                 "type": "string",

     

       50
       50
       +
                 "description": "The name of the artist."

     

       51
       51
       +
               },

     

       52
       52
       +
               "picture": {

     

       53
       53
       +
                 "type": "string",

     

       54
       54
       +
                 "description": "The picture of the artist."

     

       55
       55
       +
               },

     

       56
       56
       +
               "playCount": {

     

       57
       57
       +
                 "type": "integer",

     

       58
       58
       +
                 "description": "The number of times the artist has been played.",

     

       59
       59
       +
                 "minimum": 0

     

       60
       60
       +
               },

     

       61
       61
       +
               "sha256": {

     

       62
       62
       +
                 "type": "string",

     

       63
       63
       +
                 "description": "The SHA256 hash of the artist."

     

       64
       64
       +
               },

     

       65
       65
       +
               "uniqueListeners": {

     

       66
       66
       +
                 "type": "integer",

     

       67
       67
       +
                 "description": "The number of unique listeners who have played the artist.",

     

       68
       68
       +
                 "minimum": 0

     

       69
       69
       +
               },

     

       70
       70
       +
               "uri": {

     

       71
       71
       +
                 "type": "string",

     

       72
       72
       +
                 "description": "The URI of the artist.",

     

       73
       73
       +
                 "format": "at-uri"

     

       74
       74
       +
               }

     

       75
       75
       +
             }

     

       76
       76
       +
           }

     

       77
       77
       +
         }

     

       78
       78
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_artist_getArtist.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.getArtist",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artist details",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the artist to retrieve details from",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.artist.defs#artistViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_artist_getArtistAlbums.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.getArtistAlbums",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artist's albums",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the artist to retrieve albums from",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "albums": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.album.defs#albumViewBasic"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+45

crates/jacquard-api/lexicons/app_rocksky_artist_getArtistTracks.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.getArtistTracks",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artist's tracks",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of tracks to return",

     

       14
       14
       +
                   "minimum": 1

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "offset": {

     

       17
       17
       +
                   "type": "integer",

     

       18
       18
       +
                   "description": "The offset for pagination",

     

       19
       19
       +
                   "minimum": 0

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "uri": {

     

       22
       22
       +
                   "type": "string",

     

       23
       23
       +
                   "description": "The URI of the artist to retrieve albums from",

     

       24
       24
       +
                   "format": "at-uri"

     

       25
       25
       +
                 }

     

       26
       26
       +
               }

     

       27
       27
       +
             },

     

       28
       28
       +
             "output": {

     

       29
       29
       +
               "encoding": "application/json",

     

       30
       30
       +
               "schema": {

     

       31
       31
       +
                 "type": "object",

     

       32
       32
       +
                 "properties": {

     

       33
       33
       +
                   "tracks": {

     

       34
       34
       +
                     "type": "array",

     

       35
       35
       +
                     "items": {

     

       36
       36
       +
                       "type": "ref",

     

       37
       37
       +
                       "ref": "app.rocksky.song.defs#songViewBasic"

     

       38
       38
       +
                     }

     

       39
       39
       +
                   }

     

       40
       40
       +
                 }

     

       41
       41
       +
               }

     

       42
       42
       +
             }

     

       43
       43
       +
           }

     

       44
       44
       +
         }

     

       45
       45
       +
       }

+40

crates/jacquard-api/lexicons/app_rocksky_artist_getArtists.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.artist.getArtists",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get artists",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of artists to return",

     

       14
       14
       +
                   "minimum": 1

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "offset": {

     

       17
       17
       +
                   "type": "integer",

     

       18
       18
       +
                   "description": "The offset for pagination",

     

       19
       19
       +
                   "minimum": 0

     

       20
       20
       +
                 }

     

       21
       21
       +
               }

     

       22
       22
       +
             },

     

       23
       23
       +
             "output": {

     

       24
       24
       +
               "encoding": "application/json",

     

       25
       25
       +
               "schema": {

     

       26
       26
       +
                 "type": "object",

     

       27
       27
       +
                 "properties": {

     

       28
       28
       +
                   "artists": {

     

       29
       29
       +
                     "type": "array",

     

       30
       30
       +
                     "items": {

     

       31
       31
       +
                       "type": "ref",

     

       32
       32
       +
                       "ref": "app.rocksky.artist.defs#artistViewBasic"

     

       33
       33
       +
                     }

     

       34
       34
       +
                   }

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             }

     

       38
       38
       +
           }

     

       39
       39
       +
         }

     

       40
       40
       +
       }

+32

crates/jacquard-api/lexicons/app_rocksky_charts_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.charts.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "chartsView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "scrobbles": {

     

       9
       9
       +
                 "type": "array",

     

       10
       10
       +
                 "items": {

     

       11
       11
       +
                   "type": "ref",

     

       12
       12
       +
                   "ref": "app.rocksky.charts.defs#scrobbleViewBasic"

     

       13
       13
       +
                 }

     

       14
       14
       +
               }

     

       15
       15
       +
             }

     

       16
       16
       +
           },

     

       17
       17
       +
           "scrobbleViewBasic": {

     

       18
       18
       +
             "type": "object",

     

       19
       19
       +
             "properties": {

     

       20
       20
       +
               "count": {

     

       21
       21
       +
                 "type": "integer",

     

       22
       22
       +
                 "description": "The number of scrobbles on this date."

     

       23
       23
       +
               },

     

       24
       24
       +
               "date": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "description": "The date of the scrobble.",

     

       27
       27
       +
                 "format": "datetime"

     

       28
       28
       +
               }

     

       29
       29
       +
             }

     

       30
       30
       +
           }

     

       31
       31
       +
         }

     

       32
       32
       +
       }

+42

crates/jacquard-api/lexicons/app_rocksky_charts_getScrobblesChart.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.charts.getScrobblesChart",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get the scrobbles chart",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "albumuri": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "The URI of the album to filter by",

     

       14
       14
       +
                   "format": "at-uri"

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "artisturi": {

     

       17
       17
       +
                   "type": "string",

     

       18
       18
       +
                   "description": "The URI of the artist to filter by",

     

       19
       19
       +
                   "format": "at-uri"

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "did": {

     

       22
       22
       +
                   "type": "string",

     

       23
       23
       +
                   "description": "The DID or handle of the actor",

     

       24
       24
       +
                   "format": "at-identifier"

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "songuri": {

     

       27
       27
       +
                   "type": "string",

     

       28
       28
       +
                   "description": "The URI of the track to filter by",

     

       29
       29
       +
                   "format": "at-uri"

     

       30
       30
       +
                 }

     

       31
       31
       +
               }

     

       32
       32
       +
             },

     

       33
       33
       +
             "output": {

     

       34
       34
       +
               "encoding": "application/json",

     

       35
       35
       +
               "schema": {

     

       36
       36
       +
                 "type": "ref",

     

       37
       37
       +
                 "ref": "app.rocksky.charts.defs#chartsView"

     

       38
       38
       +
               }

     

       39
       39
       +
             }

     

       40
       40
       +
           }

     

       41
       41
       +
         }

     

       42
       42
       +
       }

+60

crates/jacquard-api/lexicons/app_rocksky_dropbox_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.dropbox.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "fileListView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "files": {

     

       9
       9
       +
                 "type": "array",

     

       10
       10
       +
                 "description": "A list of files in the Dropbox.",

     

       11
       11
       +
                 "items": {

     

       12
       12
       +
                   "type": "ref",

     

       13
       13
       +
                   "ref": "app.rocksky.dropbox.defs#fileView"

     

       14
       14
       +
                 }

     

       15
       15
       +
               }

     

       16
       16
       +
             }

     

       17
       17
       +
           },

     

       18
       18
       +
           "fileView": {

     

       19
       19
       +
             "type": "object",

     

       20
       20
       +
             "properties": {

     

       21
       21
       +
               "clientModified": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "The last modified date and time of the file on the client.",

     

       24
       24
       +
                 "format": "datetime"

     

       25
       25
       +
               },

     

       26
       26
       +
               "id": {

     

       27
       27
       +
                 "type": "string",

     

       28
       28
       +
                 "description": "The unique identifier of the file."

     

       29
       29
       +
               },

     

       30
       30
       +
               "name": {

     

       31
       31
       +
                 "type": "string",

     

       32
       32
       +
                 "description": "The name of the file."

     

       33
       33
       +
               },

     

       34
       34
       +
               "pathDisplay": {

     

       35
       35
       +
                 "type": "string",

     

       36
       36
       +
                 "description": "The display path of the file."

     

       37
       37
       +
               },

     

       38
       38
       +
               "pathLower": {

     

       39
       39
       +
                 "type": "string",

     

       40
       40
       +
                 "description": "The lowercased path of the file."

     

       41
       41
       +
               },

     

       42
       42
       +
               "serverModified": {

     

       43
       43
       +
                 "type": "string",

     

       44
       44
       +
                 "description": "The last modified date and time of the file on the server.",

     

       45
       45
       +
                 "format": "datetime"

     

       46
       46
       +
               }

     

       47
       47
       +
             }

     

       48
       48
       +
           },

     

       49
       49
       +
           "temporaryLinkView": {

     

       50
       50
       +
             "type": "object",

     

       51
       51
       +
             "properties": {

     

       52
       52
       +
               "link": {

     

       53
       53
       +
                 "type": "string",

     

       54
       54
       +
                 "description": "The temporary link to access the file.",

     

       55
       55
       +
                 "format": "uri"

     

       56
       56
       +
               }

     

       57
       57
       +
             }

     

       58
       58
       +
           }

     

       59
       59
       +
         }

     

       60
       60
       +
       }

+25

crates/jacquard-api/lexicons/app_rocksky_dropbox_downloadFile.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.dropbox.downloadFile",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Download a file from Dropbox by its unique identifier",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "fileId"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "fileId": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The unique identifier of the file to download"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/octet-stream"

     

       22
       22
       +
             }

     

       23
       23
       +
           }

     

       24
       24
       +
         }

     

       25
       25
       +
       }

+26

crates/jacquard-api/lexicons/app_rocksky_dropbox_getFiles.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.dropbox.getFiles",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Retrieve a list of files from Dropbox",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "at": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "Path to the Dropbox folder or root directory"

     

       14
       14
       +
                 }

     

       15
       15
       +
               }

     

       16
       16
       +
             },

     

       17
       17
       +
             "output": {

     

       18
       18
       +
               "encoding": "application/json",

     

       19
       19
       +
               "schema": {

     

       20
       20
       +
                 "type": "ref",

     

       21
       21
       +
                 "ref": "app.rocksky.dropbox.defs#fileListView"

     

       22
       22
       +
               }

     

       23
       23
       +
             }

     

       24
       24
       +
           }

     

       25
       25
       +
         }

     

       26
       26
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_dropbox_getMetadata.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.dropbox.getMetadata",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Retrieve metadata of a file or folder in Dropbox",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "path"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "path": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "Path to the file or folder in Dropbox"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.dropbox.defs#fileView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_dropbox_getTemporaryLink.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.dropbox.getTemporaryLink",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Retrieve a temporary link to access a file in Dropbox",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "path"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "path": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "Path to the file in Dropbox"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.dropbox.defs#temporaryLinkView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+105

crates/jacquard-api/lexicons/app_rocksky_feed_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.feed.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "nowPlayingView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "album": {

     

       9
       9
       +
                 "type": "string"

     

       10
       10
       +
               },

     

       11
       11
       +
               "albumArt": {

     

       12
       12
       +
                 "type": "string",

     

       13
       13
       +
                 "format": "uri"

     

       14
       14
       +
               },

     

       15
       15
       +
               "albumArtist": {

     

       16
       16
       +
                 "type": "string"

     

       17
       17
       +
               },

     

       18
       18
       +
               "albumUri": {

     

       19
       19
       +
                 "type": "string",

     

       20
       20
       +
                 "format": "at-uri"

     

       21
       21
       +
               },

     

       22
       22
       +
               "artist": {

     

       23
       23
       +
                 "type": "string"

     

       24
       24
       +
               },

     

       25
       25
       +
               "artistUri": {

     

       26
       26
       +
                 "type": "string",

     

       27
       27
       +
                 "format": "at-uri"

     

       28
       28
       +
               },

     

       29
       29
       +
               "avatar": {

     

       30
       30
       +
                 "type": "string",

     

       31
       31
       +
                 "format": "uri"

     

       32
       32
       +
               },

     

       33
       33
       +
               "createdAt": {

     

       34
       34
       +
                 "type": "string"

     

       35
       35
       +
               },

     

       36
       36
       +
               "did": {

     

       37
       37
       +
                 "type": "string",

     

       38
       38
       +
                 "format": "at-identifier"

     

       39
       39
       +
               },

     

       40
       40
       +
               "handle": {

     

       41
       41
       +
                 "type": "string"

     

       42
       42
       +
               },

     

       43
       43
       +
               "id": {

     

       44
       44
       +
                 "type": "string"

     

       45
       45
       +
               },

     

       46
       46
       +
               "title": {

     

       47
       47
       +
                 "type": "string"

     

       48
       48
       +
               },

     

       49
       49
       +
               "trackId": {

     

       50
       50
       +
                 "type": "string"

     

       51
       51
       +
               },

     

       52
       52
       +
               "trackUri": {

     

       53
       53
       +
                 "type": "string",

     

       54
       54
       +
                 "format": "at-uri"

     

       55
       55
       +
               },

     

       56
       56
       +
               "uri": {

     

       57
       57
       +
                 "type": "string",

     

       58
       58
       +
                 "format": "at-uri"

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           },

     

       62
       62
       +
           "nowPlayingsView": {

     

       63
       63
       +
             "type": "object",

     

       64
       64
       +
             "properties": {

     

       65
       65
       +
               "nowPlayings": {

     

       66
       66
       +
                 "type": "array",

     

       67
       67
       +
                 "items": {

     

       68
       68
       +
                   "type": "ref",

     

       69
       69
       +
                   "ref": "app.rocksky.feed.defs#nowPlayingView"

     

       70
       70
       +
                 }

     

       71
       71
       +
               }

     

       72
       72
       +
             }

     

       73
       73
       +
           },

     

       74
       74
       +
           "searchResultsView": {

     

       75
       75
       +
             "type": "object",

     

       76
       76
       +
             "properties": {

     

       77
       77
       +
               "estimatedTotalHits": {

     

       78
       78
       +
                 "type": "integer"

     

       79
       79
       +
               },

     

       80
       80
       +
               "hits": {

     

       81
       81
       +
                 "type": "array",

     

       82
       82
       +
                 "items": {

     

       83
       83
       +
                   "type": "union",

     

       84
       84
       +
                   "refs": [

     

       85
       85
       +
                     "app.rocksky.song.defs#songViewBasic",

     

       86
       86
       +
                     "app.rocksky.album.defs#albumViewBasic",

     

       87
       87
       +
                     "app.rocksky.artist.defs#artistViewBasic",

     

       88
       88
       +
                     "app.rocksky.playlist.defs#playlistViewBasic",

     

       89
       89
       +
                     "app.rocksky.actor.defs#profileViewBasic"

     

       90
       90
       +
                   ]

     

       91
       91
       +
                 }

     

       92
       92
       +
               },

     

       93
       93
       +
               "limit": {

     

       94
       94
       +
                 "type": "integer"

     

       95
       95
       +
               },

     

       96
       96
       +
               "offset": {

     

       97
       97
       +
                 "type": "integer"

     

       98
       98
       +
               },

     

       99
       99
       +
               "processingTimeMs": {

     

       100
       100
       +
                 "type": "integer"

     

       101
       101
       +
               }

     

       102
       102
       +
             }

     

       103
       103
       +
           }

     

       104
       104
       +
         }

     

       105
       105
       +
       }

+27

crates/jacquard-api/lexicons/app_rocksky_feed_getNowPlayings.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.feed.getNowPlayings",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get all currently playing tracks by users",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "size": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of now playing tracks to return.",

     

       14
       14
       +
                   "minimum": 1

     

       15
       15
       +
                 }

     

       16
       16
       +
               }

     

       17
       17
       +
             },

     

       18
       18
       +
             "output": {

     

       19
       19
       +
               "encoding": "application/json",

     

       20
       20
       +
               "schema": {

     

       21
       21
       +
                 "type": "ref",

     

       22
       22
       +
                 "ref": "app.rocksky.feed.defs#nowPlayingsView"

     

       23
       23
       +
               }

     

       24
       24
       +
             }

     

       25
       25
       +
           }

     

       26
       26
       +
         }

     

       27
       27
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_feed_search.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.feed.search",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Search for content in the feed",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "query"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "query": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The search query string"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.feed.defs#searchResultsView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+27

crates/jacquard-api/lexicons/app_rocksky_googledrive_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.googledrive.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "fileListView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "files": {

     

       9
       9
       +
                 "type": "array",

     

       10
       10
       +
                 "items": {

     

       11
       11
       +
                   "type": "ref",

     

       12
       12
       +
                   "ref": "app.rocksky.googledrive.defs#fileView"

     

       13
       13
       +
                 }

     

       14
       14
       +
               }

     

       15
       15
       +
             }

     

       16
       16
       +
           },

     

       17
       17
       +
           "fileView": {

     

       18
       18
       +
             "type": "object",

     

       19
       19
       +
             "properties": {

     

       20
       20
       +
               "id": {

     

       21
       21
       +
                 "type": "string",

     

       22
       22
       +
                 "description": "The unique identifier of the file."

     

       23
       23
       +
               }

     

       24
       24
       +
             }

     

       25
       25
       +
           }

     

       26
       26
       +
         }

     

       27
       27
       +
       }

+25

crates/jacquard-api/lexicons/app_rocksky_googledrive_downloadFile.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.googledrive.downloadFile",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Download a file from Google Drive by its unique identifier",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "fileId"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "fileId": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The unique identifier of the file to download"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/octet-stream"

     

       22
       22
       +
             }

     

       23
       23
       +
           }

     

       24
       24
       +
         }

     

       25
       25
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_googledrive_getFile.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.googledrive.getFile",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a file from Google Drive by its unique identifier",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "fileId"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "fileId": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The unique identifier of the file to retrieve"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.googledrive.defs#fileView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+26

crates/jacquard-api/lexicons/app_rocksky_googledrive_getFiles.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.googledrive.getFiles",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a list of files from Google Drive",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "at": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "Path to the Google Drive folder or root directory"

     

       14
       14
       +
                 }

     

       15
       15
       +
               }

     

       16
       16
       +
             },

     

       17
       17
       +
             "output": {

     

       18
       18
       +
               "encoding": "application/json",

     

       19
       19
       +
               "schema": {

     

       20
       20
       +
                 "type": "ref",

     

       21
       21
       +
                 "ref": "app.rocksky.googledrive.defs#fileListView"

     

       22
       22
       +
               }

     

       23
       23
       +
             }

     

       24
       24
       +
           }

     

       25
       25
       +
         }

     

       26
       26
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_like.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.like",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a like.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "createdAt",

     

       13
       13
       +
                 "subject"

     

       14
       14
       +
               ],

     

       15
       15
       +
               "properties": {

     

       16
       16
       +
                 "createdAt": {

     

       17
       17
       +
                   "type": "string",

     

       18
       18
       +
                   "description": "The date when the like was created.",

     

       19
       19
       +
                   "format": "datetime"

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "subject": {

     

       22
       22
       +
                   "type": "ref",

     

       23
       23
       +
                   "ref": "com.atproto.repo.strongRef"

     

       24
       24
       +
                 }

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_like_dislikeShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.like.dislikeShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Dislike a shout",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "properties": {

     

       13
       13
       +
                   "uri": {

     

       14
       14
       +
                     "type": "string",

     

       15
       15
       +
                     "description": "The unique identifier of the shout to dislike",

     

       16
       16
       +
                     "format": "at-uri"

     

       17
       17
       +
                   }

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_like_dislikeSong.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.like.dislikeSong",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Dislike a song",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "properties": {

     

       13
       13
       +
                   "uri": {

     

       14
       14
       +
                     "type": "string",

     

       15
       15
       +
                     "description": "The unique identifier of the song to dislike",

     

       16
       16
       +
                     "format": "at-uri"

     

       17
       17
       +
                   }

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.song.defs#songViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_like_likeShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.like.likeShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Like a shout",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "properties": {

     

       13
       13
       +
                   "uri": {

     

       14
       14
       +
                     "type": "string",

     

       15
       15
       +
                     "description": "The unique identifier of the shout to like",

     

       16
       16
       +
                     "format": "at-uri"

     

       17
       17
       +
                   }

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_like_likeSong.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.like.likeSong",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Like a song",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "properties": {

     

       13
       13
       +
                   "uri": {

     

       14
       14
       +
                     "type": "string",

     

       15
       15
       +
                     "description": "The unique identifier of the song to like",

     

       16
       16
       +
                     "format": "at-uri"

     

       17
       17
       +
                   }

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.song.defs#songViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+15

crates/jacquard-api/lexicons/app_rocksky_player_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "currentlyPlayingViewDetailed": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "title": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The title of the currently playing track"

     

       11
       11
       +
               }

     

       12
       12
       +
             }

     

       13
       13
       +
           }

     

       14
       14
       +
         }

     

       15
       15
       +
       }

+27

crates/jacquard-api/lexicons/app_rocksky_player_getCurrentlyPlaying.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.getCurrentlyPlaying",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get the currently playing track",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "actor": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",

     

       14
       14
       +
                   "format": "at-identifier"

     

       15
       15
       +
                 }

     

       16
       16
       +
               }

     

       17
       17
       +
             },

     

       18
       18
       +
             "output": {

     

       19
       19
       +
               "encoding": "application/json",

     

       20
       20
       +
               "schema": {

     

       21
       21
       +
                 "type": "ref",

     

       22
       22
       +
                 "ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"

     

       23
       23
       +
               }

     

       24
       24
       +
             }

     

       25
       25
       +
           }

     

       26
       26
       +
         }

     

       27
       27
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_player_next.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.next",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Play the next track in the queue"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_player_pause.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.pause",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Pause the currently playing track"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_player_play.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.play",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Resume playback of the currently paused track"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_player_previous.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.previous",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Play the previous track in the queue"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+22

crates/jacquard-api/lexicons/app_rocksky_player_seek.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.player.seek",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Seek to a specific position in the currently playing track",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "position"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "position": {

     

       15
       15
       +
                   "type": "integer",

     

       16
       16
       +
                   "description": "The position in seconds to seek to"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             }

     

       20
       20
       +
           }

     

       21
       21
       +
         }

     

       22
       22
       +
       }

+70

crates/jacquard-api/lexicons/app_rocksky_playlist.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.playlist",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a playlist.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "name",

     

       13
       13
       +
                 "createdAt"

     

       14
       14
       +
               ],

     

       15
       15
       +
               "properties": {

     

       16
       16
       +
                 "appleMusicLink": {

     

       17
       17
       +
                   "type": "string",

     

       18
       18
       +
                   "description": "The Apple Music link of the playlist."

     

       19
       19
       +
                 },

     

       20
       20
       +
                 "createdAt": {

     

       21
       21
       +
                   "type": "string",

     

       22
       22
       +
                   "description": "The date the playlist was created.",

     

       23
       23
       +
                   "format": "datetime"

     

       24
       24
       +
                 },

     

       25
       25
       +
                 "description": {

     

       26
       26
       +
                   "type": "string",

     

       27
       27
       +
                   "description": "The playlist description.",

     

       28
       28
       +
                   "minLength": 1,

     

       29
       29
       +
                   "maxLength": 256

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "name": {

     

       32
       32
       +
                   "type": "string",

     

       33
       33
       +
                   "description": "The name of the playlist.",

     

       34
       34
       +
                   "minLength": 1,

     

       35
       35
       +
                   "maxLength": 512

     

       36
       36
       +
                 },

     

       37
       37
       +
                 "picture": {

     

       38
       38
       +
                   "type": "blob",

     

       39
       39
       +
                   "description": "The picture of the playlist.",

     

       40
       40
       +
                   "accept": [

     

       41
       41
       +
                     "image/png",

     

       42
       42
       +
                     "image/jpeg"

     

       43
       43
       +
                   ],

     

       44
       44
       +
                   "maxSize": 2000000

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "spotifyLink": {

     

       47
       47
       +
                   "type": "string",

     

       48
       48
       +
                   "description": "The Spotify link of the playlist."

     

       49
       49
       +
                 },

     

       50
       50
       +
                 "tidalLink": {

     

       51
       51
       +
                   "type": "string",

     

       52
       52
       +
                   "description": "The Tidal link of the playlist."

     

       53
       53
       +
                 },

     

       54
       54
       +
                 "tracks": {

     

       55
       55
       +
                   "type": "array",

     

       56
       56
       +
                   "description": "The tracks in the playlist.",

     

       57
       57
       +
                   "items": {

     

       58
       58
       +
                     "type": "ref",

     

       59
       59
       +
                     "ref": "app.rocksky.song#record"

     

       60
       60
       +
                   }

     

       61
       61
       +
                 },

     

       62
       62
       +
                 "youtubeLink": {

     

       63
       63
       +
                   "type": "string",

     

       64
       64
       +
                   "description": "The YouTube link of the playlist."

     

       65
       65
       +
                 }

     

       66
       66
       +
               }

     

       67
       67
       +
             }

     

       68
       68
       +
           }

     

       69
       69
       +
         }

     

       70
       70
       +
       }

+123

crates/jacquard-api/lexicons/app_rocksky_playlist_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.playlist.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "playlistViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "description": "Basic view of a playlist, including its metadata",

     

       8
       8
       +
             "properties": {

     

       9
       9
       +
               "coverImageUrl": {

     

       10
       10
       +
                 "type": "string",

     

       11
       11
       +
                 "description": "The URL of the cover image for the playlist.",

     

       12
       12
       +
                 "format": "uri"

     

       13
       13
       +
               },

     

       14
       14
       +
               "createdAt": {

     

       15
       15
       +
                 "type": "string",

     

       16
       16
       +
                 "description": "The date and time when the playlist was created.",

     

       17
       17
       +
                 "format": "datetime"

     

       18
       18
       +
               },

     

       19
       19
       +
               "curatorAvatarUrl": {

     

       20
       20
       +
                 "type": "string",

     

       21
       21
       +
                 "description": "The URL of the avatar image of the curator.",

     

       22
       22
       +
                 "format": "uri"

     

       23
       23
       +
               },

     

       24
       24
       +
               "curatorDid": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "description": "The DID of the curator of the playlist.",

     

       27
       27
       +
                 "format": "at-identifier"

     

       28
       28
       +
               },

     

       29
       29
       +
               "curatorHandle": {

     

       30
       30
       +
                 "type": "string",

     

       31
       31
       +
                 "description": "The handle of the curator of the playlist.",

     

       32
       32
       +
                 "format": "at-identifier"

     

       33
       33
       +
               },

     

       34
       34
       +
               "curatorName": {

     

       35
       35
       +
                 "type": "string",

     

       36
       36
       +
                 "description": "The name of the curator of the playlist."

     

       37
       37
       +
               },

     

       38
       38
       +
               "description": {

     

       39
       39
       +
                 "type": "string",

     

       40
       40
       +
                 "description": "A description of the playlist."

     

       41
       41
       +
               },

     

       42
       42
       +
               "id": {

     

       43
       43
       +
                 "type": "string",

     

       44
       44
       +
                 "description": "The unique identifier of the playlist."

     

       45
       45
       +
               },

     

       46
       46
       +
               "title": {

     

       47
       47
       +
                 "type": "string",

     

       48
       48
       +
                 "description": "The title of the playlist."

     

       49
       49
       +
               },

     

       50
       50
       +
               "trackCount": {

     

       51
       51
       +
                 "type": "integer",

     

       52
       52
       +
                 "description": "The number of tracks in the playlist.",

     

       53
       53
       +
                 "minimum": 0

     

       54
       54
       +
               },

     

       55
       55
       +
               "uri": {

     

       56
       56
       +
                 "type": "string",

     

       57
       57
       +
                 "description": "The URI of the playlist.",

     

       58
       58
       +
                 "format": "at-uri"

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           },

     

       62
       62
       +
           "playlistViewDetailed": {

     

       63
       63
       +
             "type": "object",

     

       64
       64
       +
             "description": "Detailed view of a playlist, including its tracks and metadata",

     

       65
       65
       +
             "properties": {

     

       66
       66
       +
               "coverImageUrl": {

     

       67
       67
       +
                 "type": "string",

     

       68
       68
       +
                 "description": "The URL of the cover image for the playlist.",

     

       69
       69
       +
                 "format": "uri"

     

       70
       70
       +
               },

     

       71
       71
       +
               "createdAt": {

     

       72
       72
       +
                 "type": "string",

     

       73
       73
       +
                 "description": "The date and time when the playlist was created.",

     

       74
       74
       +
                 "format": "datetime"

     

       75
       75
       +
               },

     

       76
       76
       +
               "curatorAvatarUrl": {

     

       77
       77
       +
                 "type": "string",

     

       78
       78
       +
                 "description": "The URL of the avatar image of the curator.",

     

       79
       79
       +
                 "format": "uri"

     

       80
       80
       +
               },

     

       81
       81
       +
               "curatorDid": {

     

       82
       82
       +
                 "type": "string",

     

       83
       83
       +
                 "description": "The DID of the curator of the playlist.",

     

       84
       84
       +
                 "format": "at-identifier"

     

       85
       85
       +
               },

     

       86
       86
       +
               "curatorHandle": {

     

       87
       87
       +
                 "type": "string",

     

       88
       88
       +
                 "description": "The handle of the curator of the playlist.",

     

       89
       89
       +
                 "format": "at-identifier"

     

       90
       90
       +
               },

     

       91
       91
       +
               "curatorName": {

     

       92
       92
       +
                 "type": "string",

     

       93
       93
       +
                 "description": "The name of the curator of the playlist."

     

       94
       94
       +
               },

     

       95
       95
       +
               "description": {

     

       96
       96
       +
                 "type": "string",

     

       97
       97
       +
                 "description": "A description of the playlist."

     

       98
       98
       +
               },

     

       99
       99
       +
               "id": {

     

       100
       100
       +
                 "type": "string",

     

       101
       101
       +
                 "description": "The unique identifier of the playlist."

     

       102
       102
       +
               },

     

       103
       103
       +
               "title": {

     

       104
       104
       +
                 "type": "string",

     

       105
       105
       +
                 "description": "The title of the playlist."

     

       106
       106
       +
               },

     

       107
       107
       +
               "tracks": {

     

       108
       108
       +
                 "type": "array",

     

       109
       109
       +
                 "description": "A list of tracks in the playlist.",

     

       110
       110
       +
                 "items": {

     

       111
       111
       +
                   "type": "ref",

     

       112
       112
       +
                   "ref": "app.rocksky.song.defs#songViewBasic"

     

       113
       113
       +
                 }

     

       114
       114
       +
               },

     

       115
       115
       +
               "uri": {

     

       116
       116
       +
                 "type": "string",

     

       117
       117
       +
                 "description": "The URI of the playlist.",

     

       118
       118
       +
                 "format": "at-uri"

     

       119
       119
       +
               }

     

       120
       120
       +
             }

     

       121
       121
       +
           }

     

       122
       122
       +
         }

     

       123
       123
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylist.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.playlist.getPlaylist",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Retrieve a playlist by its ID",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the playlist to retrieve.",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.playlist.defs#playlistViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_playlist_getPlaylists.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.playlist.getPlaylists",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Retrieve a list of playlists",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of playlists to return."

     

       14
       14
       +
                 },

     

       15
       15
       +
                 "offset": {

     

       16
       16
       +
                   "type": "integer",

     

       17
       17
       +
                   "description": "The offset for pagination, used to skip a number of playlists."

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "playlists": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.playlist.defs#playlistViewBasic"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+63

crates/jacquard-api/lexicons/app_rocksky_radio.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.radio",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a radio station.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "name",

     

       13
       13
       +
                 "url",

     

       14
       14
       +
                 "createdAt"

     

       15
       15
       +
               ],

     

       16
       16
       +
               "properties": {

     

       17
       17
       +
                 "createdAt": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "description": "The date when the radio station was created.",

     

       20
       20
       +
                   "format": "datetime"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "description": {

     

       23
       23
       +
                   "type": "string",

     

       24
       24
       +
                   "description": "A description of the radio station.",

     

       25
       25
       +
                   "minLength": 1,

     

       26
       26
       +
                   "maxLength": 1000

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "genre": {

     

       29
       29
       +
                   "type": "string",

     

       30
       30
       +
                   "description": "The genre of the radio station.",

     

       31
       31
       +
                   "minLength": 1,

     

       32
       32
       +
                   "maxLength": 256

     

       33
       33
       +
                 },

     

       34
       34
       +
                 "logo": {

     

       35
       35
       +
                   "type": "blob",

     

       36
       36
       +
                   "description": "The logo of the radio station.",

     

       37
       37
       +
                   "accept": [

     

       38
       38
       +
                     "image/png",

     

       39
       39
       +
                     "image/jpeg"

     

       40
       40
       +
                   ],

     

       41
       41
       +
                   "maxSize": 2000000

     

       42
       42
       +
                 },

     

       43
       43
       +
                 "name": {

     

       44
       44
       +
                   "type": "string",

     

       45
       45
       +
                   "description": "The name of the radio station.",

     

       46
       46
       +
                   "minLength": 1,

     

       47
       47
       +
                   "maxLength": 512

     

       48
       48
       +
                 },

     

       49
       49
       +
                 "url": {

     

       50
       50
       +
                   "type": "string",

     

       51
       51
       +
                   "description": "The URL of the radio station.",

     

       52
       52
       +
                   "format": "uri"

     

       53
       53
       +
                 },

     

       54
       54
       +
                 "website": {

     

       55
       55
       +
                   "type": "string",

     

       56
       56
       +
                   "description": "The website of the radio station.",

     

       57
       57
       +
                   "format": "uri"

     

       58
       58
       +
                 }

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           }

     

       62
       62
       +
         }

     

       63
       63
       +
       }

+68

crates/jacquard-api/lexicons/app_rocksky_radio_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.radio.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "radioViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "createdAt": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The date and time when the radio was created.",

     

       11
       11
       +
                 "format": "datetime"

     

       12
       12
       +
               },

     

       13
       13
       +
               "description": {

     

       14
       14
       +
                 "type": "string",

     

       15
       15
       +
                 "description": "A brief description of the radio."

     

       16
       16
       +
               },

     

       17
       17
       +
               "id": {

     

       18
       18
       +
                 "type": "string",

     

       19
       19
       +
                 "description": "The unique identifier of the radio."

     

       20
       20
       +
               },

     

       21
       21
       +
               "name": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "The name of the radio."

     

       24
       24
       +
               }

     

       25
       25
       +
             }

     

       26
       26
       +
           },

     

       27
       27
       +
           "radioViewDetailed": {

     

       28
       28
       +
             "type": "object",

     

       29
       29
       +
             "properties": {

     

       30
       30
       +
               "createdAt": {

     

       31
       31
       +
                 "type": "string",

     

       32
       32
       +
                 "description": "The date and time when the radio was created.",

     

       33
       33
       +
                 "format": "datetime"

     

       34
       34
       +
               },

     

       35
       35
       +
               "description": {

     

       36
       36
       +
                 "type": "string",

     

       37
       37
       +
                 "description": "A brief description of the radio."

     

       38
       38
       +
               },

     

       39
       39
       +
               "genre": {

     

       40
       40
       +
                 "type": "string",

     

       41
       41
       +
                 "description": "The genre of the radio."

     

       42
       42
       +
               },

     

       43
       43
       +
               "id": {

     

       44
       44
       +
                 "type": "string",

     

       45
       45
       +
                 "description": "The unique identifier of the radio."

     

       46
       46
       +
               },

     

       47
       47
       +
               "logo": {

     

       48
       48
       +
                 "type": "string",

     

       49
       49
       +
                 "description": "The logo of the radio station."

     

       50
       50
       +
               },

     

       51
       51
       +
               "name": {

     

       52
       52
       +
                 "type": "string",

     

       53
       53
       +
                 "description": "The name of the radio."

     

       54
       54
       +
               },

     

       55
       55
       +
               "url": {

     

       56
       56
       +
                 "type": "string",

     

       57
       57
       +
                 "description": "The streaming URL of the radio.",

     

       58
       58
       +
                 "format": "uri"

     

       59
       59
       +
               },

     

       60
       60
       +
               "website": {

     

       61
       61
       +
                 "type": "string",

     

       62
       62
       +
                 "description": "The website of the radio.",

     

       63
       63
       +
                 "format": "uri"

     

       64
       64
       +
               }

     

       65
       65
       +
             }

     

       66
       66
       +
           }

     

       67
       67
       +
         }

     

       68
       68
       +
       }

+149

crates/jacquard-api/lexicons/app_rocksky_scrobble.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.scrobble",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a scrobble.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "title",

     

       13
       13
       +
                 "artist",

     

       14
       14
       +
                 "album",

     

       15
       15
       +
                 "albumArtist",

     

       16
       16
       +
                 "duration",

     

       17
       17
       +
                 "createdAt"

     

       18
       18
       +
               ],

     

       19
       19
       +
               "properties": {

     

       20
       20
       +
                 "album": {

     

       21
       21
       +
                   "type": "string",

     

       22
       22
       +
                   "description": "The album of the song.",

     

       23
       23
       +
                   "minLength": 1,

     

       24
       24
       +
                   "maxLength": 256

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "albumArt": {

     

       27
       27
       +
                   "type": "blob",

     

       28
       28
       +
                   "description": "The album art of the song.",

     

       29
       29
       +
                   "accept": [

     

       30
       30
       +
                     "image/png",

     

       31
       31
       +
                     "image/jpeg"

     

       32
       32
       +
                   ],

     

       33
       33
       +
                   "maxSize": 2000000

     

       34
       34
       +
                 },

     

       35
       35
       +
                 "albumArtist": {

     

       36
       36
       +
                   "type": "string",

     

       37
       37
       +
                   "description": "The album artist of the song.",

     

       38
       38
       +
                   "minLength": 1,

     

       39
       39
       +
                   "maxLength": 256

     

       40
       40
       +
                 },

     

       41
       41
       +
                 "appleMusicLink": {

     

       42
       42
       +
                   "type": "string",

     

       43
       43
       +
                   "description": "The Apple Music link of the song.",

     

       44
       44
       +
                   "format": "uri"

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "artist": {

     

       47
       47
       +
                   "type": "string",

     

       48
       48
       +
                   "description": "The artist of the song.",

     

       49
       49
       +
                   "minLength": 1,

     

       50
       50
       +
                   "maxLength": 256

     

       51
       51
       +
                 },

     

       52
       52
       +
                 "composer": {

     

       53
       53
       +
                   "type": "string",

     

       54
       54
       +
                   "description": "The composer of the song.",

     

       55
       55
       +
                   "maxLength": 256

     

       56
       56
       +
                 },

     

       57
       57
       +
                 "copyrightMessage": {

     

       58
       58
       +
                   "type": "string",

     

       59
       59
       +
                   "description": "The copyright message of the song.",

     

       60
       60
       +
                   "maxLength": 256

     

       61
       61
       +
                 },

     

       62
       62
       +
                 "createdAt": {

     

       63
       63
       +
                   "type": "string",

     

       64
       64
       +
                   "description": "The date when the song was created.",

     

       65
       65
       +
                   "format": "datetime"

     

       66
       66
       +
                 },

     

       67
       67
       +
                 "discNumber": {

     

       68
       68
       +
                   "type": "integer",

     

       69
       69
       +
                   "description": "The disc number of the song in the album.",

     

       70
       70
       +
                   "minimum": 1

     

       71
       71
       +
                 },

     

       72
       72
       +
                 "duration": {

     

       73
       73
       +
                   "type": "integer",

     

       74
       74
       +
                   "description": "The duration of the song in seconds.",

     

       75
       75
       +
                   "minimum": 1

     

       76
       76
       +
                 },

     

       77
       77
       +
                 "genre": {

     

       78
       78
       +
                   "type": "string",

     

       79
       79
       +
                   "description": "The genre of the song.",

     

       80
       80
       +
                   "maxLength": 256

     

       81
       81
       +
                 },

     

       82
       82
       +
                 "label": {

     

       83
       83
       +
                   "type": "string",

     

       84
       84
       +
                   "description": "The label of the song.",

     

       85
       85
       +
                   "maxLength": 256

     

       86
       86
       +
                 },

     

       87
       87
       +
                 "lyrics": {

     

       88
       88
       +
                   "type": "string",

     

       89
       89
       +
                   "description": "The lyrics of the song.",

     

       90
       90
       +
                   "maxLength": 10000

     

       91
       91
       +
                 },

     

       92
       92
       +
                 "mbid": {

     

       93
       93
       +
                   "type": "string",

     

       94
       94
       +
                   "description": "The MusicBrainz ID of the song."

     

       95
       95
       +
                 },

     

       96
       96
       +
                 "releaseDate": {

     

       97
       97
       +
                   "type": "string",

     

       98
       98
       +
                   "description": "The release date of the song.",

     

       99
       99
       +
                   "format": "datetime"

     

       100
       100
       +
                 },

     

       101
       101
       +
                 "spotifyLink": {

     

       102
       102
       +
                   "type": "string",

     

       103
       103
       +
                   "description": "The Spotify link of the song.",

     

       104
       104
       +
                   "format": "uri"

     

       105
       105
       +
                 },

     

       106
       106
       +
                 "tags": {

     

       107
       107
       +
                   "type": "array",

     

       108
       108
       +
                   "description": "The tags of the song.",

     

       109
       109
       +
                   "items": {

     

       110
       110
       +
                     "type": "string",

     

       111
       111
       +
                     "minLength": 1,

     

       112
       112
       +
                     "maxLength": 256

     

       113
       113
       +
                   }

     

       114
       114
       +
                 },

     

       115
       115
       +
                 "tidalLink": {

     

       116
       116
       +
                   "type": "string",

     

       117
       117
       +
                   "description": "The Tidal link of the song.",

     

       118
       118
       +
                   "format": "uri"

     

       119
       119
       +
                 },

     

       120
       120
       +
                 "title": {

     

       121
       121
       +
                   "type": "string",

     

       122
       122
       +
                   "description": "The title of the song.",

     

       123
       123
       +
                   "minLength": 1,

     

       124
       124
       +
                   "maxLength": 512

     

       125
       125
       +
                 },

     

       126
       126
       +
                 "trackNumber": {

     

       127
       127
       +
                   "type": "integer",

     

       128
       128
       +
                   "description": "The track number of the song in the album.",

     

       129
       129
       +
                   "minimum": 1

     

       130
       130
       +
                 },

     

       131
       131
       +
                 "wiki": {

     

       132
       132
       +
                   "type": "string",

     

       133
       133
       +
                   "description": "Informations about the song",

     

       134
       134
       +
                   "maxLength": 10000

     

       135
       135
       +
                 },

     

       136
       136
       +
                 "year": {

     

       137
       137
       +
                   "type": "integer",

     

       138
       138
       +
                   "description": "The year the song was released."

     

       139
       139
       +
                 },

     

       140
       140
       +
                 "youtubeLink": {

     

       141
       141
       +
                   "type": "string",

     

       142
       142
       +
                   "description": "The YouTube link of the song.",

     

       143
       143
       +
                   "format": "uri"

     

       144
       144
       +
                 }

     

       145
       145
       +
               }

     

       146
       146
       +
             }

     

       147
       147
       +
           }

     

       148
       148
       +
         }

     

       149
       149
       +
       }

+125

crates/jacquard-api/lexicons/app_rocksky_scrobble_createScrobble.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.scrobble.createScrobble",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Create a new scrobble",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "title",

     

       14
       14
       +
                   "artist"

     

       15
       15
       +
                 ],

     

       16
       16
       +
                 "properties": {

     

       17
       17
       +
                   "album": {

     

       18
       18
       +
                     "type": "string",

     

       19
       19
       +
                     "description": "The album of the track being scrobbled"

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "albumArt": {

     

       22
       22
       +
                     "type": "string",

     

       23
       23
       +
                     "description": "The URL of the album art for the track",

     

       24
       24
       +
                     "format": "uri"

     

       25
       25
       +
                   },

     

       26
       26
       +
                   "appleMusicLink": {

     

       27
       27
       +
                     "type": "string",

     

       28
       28
       +
                     "description": "The Apple Music link for the track, if available",

     

       29
       29
       +
                     "format": "uri"

     

       30
       30
       +
                   },

     

       31
       31
       +
                   "artist": {

     

       32
       32
       +
                     "type": "string",

     

       33
       33
       +
                     "description": "The artist of the track being scrobbled"

     

       34
       34
       +
                   },

     

       35
       35
       +
                   "artistPicture": {

     

       36
       36
       +
                     "type": "string",

     

       37
       37
       +
                     "description": "The URL of the artist's picture, if available",

     

       38
       38
       +
                     "format": "uri"

     

       39
       39
       +
                   },

     

       40
       40
       +
                   "composer": {

     

       41
       41
       +
                     "type": "string",

     

       42
       42
       +
                     "description": "The composer of the track, if available"

     

       43
       43
       +
                   },

     

       44
       44
       +
                   "copyrightMessage": {

     

       45
       45
       +
                     "type": "string",

     

       46
       46
       +
                     "description": "The copyright message for the track, if available"

     

       47
       47
       +
                   },

     

       48
       48
       +
                   "deezerLink": {

     

       49
       49
       +
                     "type": "string",

     

       50
       50
       +
                     "description": "The Deezer link for the track, if available",

     

       51
       51
       +
                     "format": "uri"

     

       52
       52
       +
                   },

     

       53
       53
       +
                   "discNumber": {

     

       54
       54
       +
                     "type": "integer",

     

       55
       55
       +
                     "description": "The disc number of the track in the album, if applicable"

     

       56
       56
       +
                   },

     

       57
       57
       +
                   "duration": {

     

       58
       58
       +
                     "type": "integer",

     

       59
       59
       +
                     "description": "The duration of the track in seconds"

     

       60
       60
       +
                   },

     

       61
       61
       +
                   "label": {

     

       62
       62
       +
                     "type": "string",

     

       63
       63
       +
                     "description": "The record label of the track, if available"

     

       64
       64
       +
                   },

     

       65
       65
       +
                   "lastfmLink": {

     

       66
       66
       +
                     "type": "string",

     

       67
       67
       +
                     "description": "The Last.fm link for the track, if available",

     

       68
       68
       +
                     "format": "uri"

     

       69
       69
       +
                   },

     

       70
       70
       +
                   "lyrics": {

     

       71
       71
       +
                     "type": "string",

     

       72
       72
       +
                     "description": "The lyrics of the track, if available"

     

       73
       73
       +
                   },

     

       74
       74
       +
                   "mbId": {

     

       75
       75
       +
                     "type": "string",

     

       76
       76
       +
                     "description": "The MusicBrainz ID of the track, if available"

     

       77
       77
       +
                   },

     

       78
       78
       +
                   "releaseDate": {

     

       79
       79
       +
                     "type": "string",

     

       80
       80
       +
                     "description": "The release date of the track, formatted as YYYY-MM-DD"

     

       81
       81
       +
                   },

     

       82
       82
       +
                   "spotifyLink": {

     

       83
       83
       +
                     "type": "string",

     

       84
       84
       +
                     "description": "The Spotify link for the track, if available",

     

       85
       85
       +
                     "format": "uri"

     

       86
       86
       +
                   },

     

       87
       87
       +
                   "tidalLink": {

     

       88
       88
       +
                     "type": "string",

     

       89
       89
       +
                     "description": "The Tidal link for the track, if available",

     

       90
       90
       +
                     "format": "uri"

     

       91
       91
       +
                   },

     

       92
       92
       +
                   "timestamp": {

     

       93
       93
       +
                     "type": "integer",

     

       94
       94
       +
                     "description": "The timestamp of the scrobble in milliseconds since epoch"

     

       95
       95
       +
                   },

     

       96
       96
       +
                   "title": {

     

       97
       97
       +
                     "type": "string",

     

       98
       98
       +
                     "description": "The title of the track being scrobbled"

     

       99
       99
       +
                   },

     

       100
       100
       +
                   "trackNumber": {

     

       101
       101
       +
                     "type": "integer",

     

       102
       102
       +
                     "description": "The track number of the track in the album"

     

       103
       103
       +
                   },

     

       104
       104
       +
                   "year": {

     

       105
       105
       +
                     "type": "integer",

     

       106
       106
       +
                     "description": "The year the track was released"

     

       107
       107
       +
                   },

     

       108
       108
       +
                   "youtubeLink": {

     

       109
       109
       +
                     "type": "string",

     

       110
       110
       +
                     "description": "The Youtube link for the track, if available",

     

       111
       111
       +
                     "format": "uri"

     

       112
       112
       +
                   }

     

       113
       113
       +
                 }

     

       114
       114
       +
               }

     

       115
       115
       +
             },

     

       116
       116
       +
             "output": {

     

       117
       117
       +
               "encoding": "application/json",

     

       118
       118
       +
               "schema": {

     

       119
       119
       +
                 "type": "ref",

     

       120
       120
       +
                 "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"

     

       121
       121
       +
               }

     

       122
       122
       +
             }

     

       123
       123
       +
           }

     

       124
       124
       +
         }

     

       125
       125
       +
       }

+122

crates/jacquard-api/lexicons/app_rocksky_scrobble_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.scrobble.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "scrobbleViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "album": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The album of the song."

     

       11
       11
       +
               },

     

       12
       12
       +
               "albumUri": {

     

       13
       13
       +
                 "type": "string",

     

       14
       14
       +
                 "description": "The URI of the album.",

     

       15
       15
       +
                 "format": "at-uri"

     

       16
       16
       +
               },

     

       17
       17
       +
               "artist": {

     

       18
       18
       +
                 "type": "string",

     

       19
       19
       +
                 "description": "The artist of the song."

     

       20
       20
       +
               },

     

       21
       21
       +
               "artistUri": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "The URI of the artist.",

     

       24
       24
       +
                 "format": "at-uri"

     

       25
       25
       +
               },

     

       26
       26
       +
               "cover": {

     

       27
       27
       +
                 "type": "string",

     

       28
       28
       +
                 "description": "The album art URL of the song.",

     

       29
       29
       +
                 "format": "uri"

     

       30
       30
       +
               },

     

       31
       31
       +
               "date": {

     

       32
       32
       +
                 "type": "string",

     

       33
       33
       +
                 "description": "The timestamp when the scrobble was created.",

     

       34
       34
       +
                 "format": "datetime"

     

       35
       35
       +
               },

     

       36
       36
       +
               "id": {

     

       37
       37
       +
                 "type": "string",

     

       38
       38
       +
                 "description": "The unique identifier of the scrobble."

     

       39
       39
       +
               },

     

       40
       40
       +
               "sha256": {

     

       41
       41
       +
                 "type": "string",

     

       42
       42
       +
                 "description": "The SHA256 hash of the scrobble data."

     

       43
       43
       +
               },

     

       44
       44
       +
               "title": {

     

       45
       45
       +
                 "type": "string",

     

       46
       46
       +
                 "description": "The title of the scrobble."

     

       47
       47
       +
               },

     

       48
       48
       +
               "uri": {

     

       49
       49
       +
                 "type": "string",

     

       50
       50
       +
                 "description": "The URI of the scrobble.",

     

       51
       51
       +
                 "format": "uri"

     

       52
       52
       +
               },

     

       53
       53
       +
               "user": {

     

       54
       54
       +
                 "type": "string",

     

       55
       55
       +
                 "description": "The handle of the user who created the scrobble."

     

       56
       56
       +
               }

     

       57
       57
       +
             }

     

       58
       58
       +
           },

     

       59
       59
       +
           "scrobbleViewDetailed": {

     

       60
       60
       +
             "type": "object",

     

       61
       61
       +
             "properties": {

     

       62
       62
       +
               "album": {

     

       63
       63
       +
                 "type": "string",

     

       64
       64
       +
                 "description": "The album of the song."

     

       65
       65
       +
               },

     

       66
       66
       +
               "albumUri": {

     

       67
       67
       +
                 "type": "string",

     

       68
       68
       +
                 "description": "The URI of the album.",

     

       69
       69
       +
                 "format": "at-uri"

     

       70
       70
       +
               },

     

       71
       71
       +
               "artist": {

     

       72
       72
       +
                 "type": "string",

     

       73
       73
       +
                 "description": "The artist of the song."

     

       74
       74
       +
               },

     

       75
       75
       +
               "artistUri": {

     

       76
       76
       +
                 "type": "string",

     

       77
       77
       +
                 "description": "The URI of the artist.",

     

       78
       78
       +
                 "format": "at-uri"

     

       79
       79
       +
               },

     

       80
       80
       +
               "cover": {

     

       81
       81
       +
                 "type": "string",

     

       82
       82
       +
                 "description": "The album art URL of the song.",

     

       83
       83
       +
                 "format": "uri"

     

       84
       84
       +
               },

     

       85
       85
       +
               "date": {

     

       86
       86
       +
                 "type": "string",

     

       87
       87
       +
                 "description": "The timestamp when the scrobble was created.",

     

       88
       88
       +
                 "format": "datetime"

     

       89
       89
       +
               },

     

       90
       90
       +
               "id": {

     

       91
       91
       +
                 "type": "string",

     

       92
       92
       +
                 "description": "The unique identifier of the scrobble."

     

       93
       93
       +
               },

     

       94
       94
       +
               "listeners": {

     

       95
       95
       +
                 "type": "integer",

     

       96
       96
       +
                 "description": "The number of listeners"

     

       97
       97
       +
               },

     

       98
       98
       +
               "scrobbles": {

     

       99
       99
       +
                 "type": "integer",

     

       100
       100
       +
                 "description": "The number of scrobbles for this song"

     

       101
       101
       +
               },

     

       102
       102
       +
               "sha256": {

     

       103
       103
       +
                 "type": "string",

     

       104
       104
       +
                 "description": "The SHA256 hash of the scrobble data."

     

       105
       105
       +
               },

     

       106
       106
       +
               "title": {

     

       107
       107
       +
                 "type": "string",

     

       108
       108
       +
                 "description": "The title of the scrobble."

     

       109
       109
       +
               },

     

       110
       110
       +
               "uri": {

     

       111
       111
       +
                 "type": "string",

     

       112
       112
       +
                 "description": "The URI of the scrobble.",

     

       113
       113
       +
                 "format": "uri"

     

       114
       114
       +
               },

     

       115
       115
       +
               "user": {

     

       116
       116
       +
                 "type": "string",

     

       117
       117
       +
                 "description": "The handle of the user who created the scrobble."

     

       118
       118
       +
               }

     

       119
       119
       +
             }

     

       120
       120
       +
           }

     

       121
       121
       +
         }

     

       122
       122
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobble.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.scrobble.getScrobble",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a scrobble by its unique identifier",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The unique identifier of the scrobble",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.scrobble.defs#scrobbleViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+45

crates/jacquard-api/lexicons/app_rocksky_scrobble_getScrobbles.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.scrobble.getScrobbles",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get scrobbles all scrobbles",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "did": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "The DID or handle of the actor",

     

       14
       14
       +
                   "format": "at-identifier"

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "limit": {

     

       17
       17
       +
                   "type": "integer",

     

       18
       18
       +
                   "description": "The maximum number of scrobbles to return",

     

       19
       19
       +
                   "minimum": 1

     

       20
       20
       +
                 },

     

       21
       21
       +
                 "offset": {

     

       22
       22
       +
                   "type": "integer",

     

       23
       23
       +
                   "description": "The offset for pagination",

     

       24
       24
       +
                   "minimum": 0

     

       25
       25
       +
                 }

     

       26
       26
       +
               }

     

       27
       27
       +
             },

     

       28
       28
       +
             "output": {

     

       29
       29
       +
               "encoding": "application/json",

     

       30
       30
       +
               "schema": {

     

       31
       31
       +
                 "type": "object",

     

       32
       32
       +
                 "properties": {

     

       33
       33
       +
                   "scrobbles": {

     

       34
       34
       +
                     "type": "array",

     

       35
       35
       +
                     "items": {

     

       36
       36
       +
                       "type": "ref",

     

       37
       37
       +
                       "ref": "app.rocksky.scrobble.defs#scrobbleViewBasic"

     

       38
       38
       +
                     }

     

       39
       39
       +
                   }

     

       40
       40
       +
                 }

     

       41
       41
       +
               }

     

       42
       42
       +
             }

     

       43
       43
       +
           }

     

       44
       44
       +
         }

     

       45
       45
       +
       }

+40

crates/jacquard-api/lexicons/app_rocksky_shout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a shout.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "message",

     

       13
       13
       +
                 "createdAt",

     

       14
       14
       +
                 "subject"

     

       15
       15
       +
               ],

     

       16
       16
       +
               "properties": {

     

       17
       17
       +
                 "createdAt": {

     

       18
       18
       +
                   "type": "string",

     

       19
       19
       +
                   "description": "The date when the shout was created.",

     

       20
       20
       +
                   "format": "datetime"

     

       21
       21
       +
                 },

     

       22
       22
       +
                 "message": {

     

       23
       23
       +
                   "type": "string",

     

       24
       24
       +
                   "description": "The message of the shout.",

     

       25
       25
       +
                   "minLength": 1,

     

       26
       26
       +
                   "maxLength": 1000

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "parent": {

     

       29
       29
       +
                   "type": "ref",

     

       30
       30
       +
                   "ref": "com.atproto.repo.strongRef"

     

       31
       31
       +
                 },

     

       32
       32
       +
                 "subject": {

     

       33
       33
       +
                   "type": "ref",

     

       34
       34
       +
                   "ref": "com.atproto.repo.strongRef"

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             }

     

       38
       38
       +
           }

     

       39
       39
       +
         }

     

       40
       40
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_shout_createShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.createShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Create a new shout",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "properties": {

     

       13
       13
       +
                   "message": {

     

       14
       14
       +
                     "type": "string",

     

       15
       15
       +
                     "description": "The content of the shout",

     

       16
       16
       +
                     "minLength": 1

     

       17
       17
       +
                   }

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+61

crates/jacquard-api/lexicons/app_rocksky_shout_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "author": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "avatar": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The URL of the author's avatar image.",

     

       11
       11
       +
                 "format": "uri"

     

       12
       12
       +
               },

     

       13
       13
       +
               "did": {

     

       14
       14
       +
                 "type": "string",

     

       15
       15
       +
                 "description": "The decentralized identifier (DID) of the author.",

     

       16
       16
       +
                 "format": "at-identifier"

     

       17
       17
       +
               },

     

       18
       18
       +
               "displayName": {

     

       19
       19
       +
                 "type": "string",

     

       20
       20
       +
                 "description": "The display name of the author."

     

       21
       21
       +
               },

     

       22
       22
       +
               "handle": {

     

       23
       23
       +
                 "type": "string",

     

       24
       24
       +
                 "description": "The handle of the author.",

     

       25
       25
       +
                 "format": "at-identifier"

     

       26
       26
       +
               },

     

       27
       27
       +
               "id": {

     

       28
       28
       +
                 "type": "string",

     

       29
       29
       +
                 "description": "The unique identifier of the author."

     

       30
       30
       +
               }

     

       31
       31
       +
             }

     

       32
       32
       +
           },

     

       33
       33
       +
           "shoutView": {

     

       34
       34
       +
             "type": "object",

     

       35
       35
       +
             "properties": {

     

       36
       36
       +
               "author": {

     

       37
       37
       +
                 "type": "ref",

     

       38
       38
       +
                 "description": "The author of the shout.",

     

       39
       39
       +
                 "ref": "app.rocksky.shout.defs#author"

     

       40
       40
       +
               },

     

       41
       41
       +
               "createdAt": {

     

       42
       42
       +
                 "type": "string",

     

       43
       43
       +
                 "description": "The date and time when the shout was created.",

     

       44
       44
       +
                 "format": "datetime"

     

       45
       45
       +
               },

     

       46
       46
       +
               "id": {

     

       47
       47
       +
                 "type": "string",

     

       48
       48
       +
                 "description": "The unique identifier of the shout."

     

       49
       49
       +
               },

     

       50
       50
       +
               "message": {

     

       51
       51
       +
                 "type": "string",

     

       52
       52
       +
                 "description": "The content of the shout."

     

       53
       53
       +
               },

     

       54
       54
       +
               "parent": {

     

       55
       55
       +
                 "type": "string",

     

       56
       56
       +
                 "description": "The ID of the parent shout if this is a reply, otherwise null."

     

       57
       57
       +
               }

     

       58
       58
       +
             }

     

       59
       59
       +
           }

     

       60
       60
       +
         }

     

       61
       61
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_shout_getAlbumShouts.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.getAlbumShouts",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get shouts for an album",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "limit": {

     

       15
       15
       +
                   "type": "integer",

     

       16
       16
       +
                   "description": "The maximum number of shouts to return",

     

       17
       17
       +
                   "minimum": 1

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "offset": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The number of shouts to skip before starting to collect the result set",

     

       22
       22
       +
                   "minimum": 0

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "uri": {

     

       25
       25
       +
                   "type": "string",

     

       26
       26
       +
                   "description": "The unique identifier of the album to retrieve shouts for",

     

       27
       27
       +
                   "format": "at-uri"

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "shouts": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.shout.defs#shoutViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_shout_getArtistShouts.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.getArtistShouts",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get shouts for an artist",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "limit": {

     

       15
       15
       +
                   "type": "integer",

     

       16
       16
       +
                   "description": "The maximum number of shouts to return",

     

       17
       17
       +
                   "minimum": 1

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "offset": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The number of shouts to skip before starting to collect the result set",

     

       22
       22
       +
                   "minimum": 0

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "uri": {

     

       25
       25
       +
                   "type": "string",

     

       26
       26
       +
                   "description": "The URI of the artist to retrieve shouts for",

     

       27
       27
       +
                   "format": "at-uri"

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "shouts": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.shout.defs#shoutViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_shout_getProfileShouts.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.getProfileShouts",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get the shouts of an actor's profile",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "did"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "did": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The DID or handle of the actor",

     

       17
       17
       +
                   "format": "at-identifier"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "limit": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The maximum number of shouts to return",

     

       22
       22
       +
                   "minimum": 1

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "offset": {

     

       25
       25
       +
                   "type": "integer",

     

       26
       26
       +
                   "description": "The offset for pagination",

     

       27
       27
       +
                   "minimum": 0

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "shouts": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.shout.defs#shoutViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+48

crates/jacquard-api/lexicons/app_rocksky_shout_getShoutReplies.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.getShoutReplies",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get replies to a shout",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "limit": {

     

       15
       15
       +
                   "type": "integer",

     

       16
       16
       +
                   "description": "The maximum number of shouts to return",

     

       17
       17
       +
                   "minimum": 1

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "offset": {

     

       20
       20
       +
                   "type": "integer",

     

       21
       21
       +
                   "description": "The number of shouts to skip before starting to collect the result set",

     

       22
       22
       +
                   "minimum": 0

     

       23
       23
       +
                 },

     

       24
       24
       +
                 "uri": {

     

       25
       25
       +
                   "type": "string",

     

       26
       26
       +
                   "description": "The URI of the shout to retrieve replies for",

     

       27
       27
       +
                   "format": "at-uri"

     

       28
       28
       +
                 }

     

       29
       29
       +
               }

     

       30
       30
       +
             },

     

       31
       31
       +
             "output": {

     

       32
       32
       +
               "encoding": "application/json",

     

       33
       33
       +
               "schema": {

     

       34
       34
       +
                 "type": "object",

     

       35
       35
       +
                 "properties": {

     

       36
       36
       +
                   "shouts": {

     

       37
       37
       +
                     "type": "array",

     

       38
       38
       +
                     "items": {

     

       39
       39
       +
                       "type": "ref",

     

       40
       40
       +
                       "ref": "app.rocksky.shout.defs#shoutViewBasic"

     

       41
       41
       +
                     }

     

       42
       42
       +
                   }

     

       43
       43
       +
                 }

     

       44
       44
       +
               }

     

       45
       45
       +
             }

     

       46
       46
       +
           }

     

       47
       47
       +
         }

     

       48
       48
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_shout_getTrackShouts.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.getTrackShouts",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get all shouts for a specific track",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The URI of the track to retrieve shouts for",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "object",

     

       25
       25
       +
                 "properties": {

     

       26
       26
       +
                   "shouts": {

     

       27
       27
       +
                     "type": "array",

     

       28
       28
       +
                     "items": {

     

       29
       29
       +
                       "type": "ref",

     

       30
       30
       +
                       "ref": "app.rocksky.shout.defs#shoutViewBasic"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   }

     

       33
       33
       +
                 }

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_shout_removeShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.removeShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Remove a shout by its ID",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "id"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "id": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The ID of the shout to be removed"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+38

crates/jacquard-api/lexicons/app_rocksky_shout_replyShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.replyShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Reply to a shout",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "shoutId",

     

       14
       14
       +
                   "message"

     

       15
       15
       +
                 ],

     

       16
       16
       +
                 "properties": {

     

       17
       17
       +
                   "message": {

     

       18
       18
       +
                     "type": "string",

     

       19
       19
       +
                     "description": "The content of the reply",

     

       20
       20
       +
                     "minLength": 1

     

       21
       21
       +
                   },

     

       22
       22
       +
                   "shoutId": {

     

       23
       23
       +
                     "type": "string",

     

       24
       24
       +
                     "description": "The unique identifier of the shout to reply to"

     

       25
       25
       +
                   }

     

       26
       26
       +
                 }

     

       27
       27
       +
               }

     

       28
       28
       +
             },

     

       29
       29
       +
             "output": {

     

       30
       30
       +
               "encoding": "application/json",

     

       31
       31
       +
               "schema": {

     

       32
       32
       +
                 "type": "ref",

     

       33
       33
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       34
       34
       +
               }

     

       35
       35
       +
             }

     

       36
       36
       +
           }

     

       37
       37
       +
         }

     

       38
       38
       +
       }

+37

crates/jacquard-api/lexicons/app_rocksky_shout_reportShout.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.shout.reportShout",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Report a shout for moderation",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "shoutId"

     

       14
       14
       +
                 ],

     

       15
       15
       +
                 "properties": {

     

       16
       16
       +
                   "reason": {

     

       17
       17
       +
                     "type": "string",

     

       18
       18
       +
                     "description": "The reason for reporting the shout",

     

       19
       19
       +
                     "minLength": 1

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "shoutId": {

     

       22
       22
       +
                     "type": "string",

     

       23
       23
       +
                     "description": "The unique identifier of the shout to report"

     

       24
       24
       +
                   }

     

       25
       25
       +
                 }

     

       26
       26
       +
               }

     

       27
       27
       +
             },

     

       28
       28
       +
             "output": {

     

       29
       29
       +
               "encoding": "application/json",

     

       30
       30
       +
               "schema": {

     

       31
       31
       +
                 "type": "ref",

     

       32
       32
       +
                 "ref": "app.rocksky.shout.defs#shoutView"

     

       33
       33
       +
               }

     

       34
       34
       +
             }

     

       35
       35
       +
           }

     

       36
       36
       +
         }

     

       37
       37
       +
       }

+150

crates/jacquard-api/lexicons/app_rocksky_song.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.song",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "record",

     

       7
       7
       +
             "description": "A declaration of a song.",

     

       8
       8
       +
             "key": "tid",

     

       9
       9
       +
             "record": {

     

       10
       10
       +
               "type": "object",

     

       11
       11
       +
               "required": [

     

       12
       12
       +
                 "title",

     

       13
       13
       +
                 "artist",

     

       14
       14
       +
                 "album",

     

       15
       15
       +
                 "albumArtist",

     

       16
       16
       +
                 "duration",

     

       17
       17
       +
                 "createdAt"

     

       18
       18
       +
               ],

     

       19
       19
       +
               "properties": {

     

       20
       20
       +
                 "album": {

     

       21
       21
       +
                   "type": "string",

     

       22
       22
       +
                   "description": "The album of the song.",

     

       23
       23
       +
                   "minLength": 1,

     

       24
       24
       +
                   "maxLength": 256

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "albumArt": {

     

       27
       27
       +
                   "type": "blob",

     

       28
       28
       +
                   "description": "The album art of the song.",

     

       29
       29
       +
                   "accept": [

     

       30
       30
       +
                     "image/png",

     

       31
       31
       +
                     "image/jpeg"

     

       32
       32
       +
                   ],

     

       33
       33
       +
                   "maxSize": 2000000

     

       34
       34
       +
                 },

     

       35
       35
       +
                 "albumArtist": {

     

       36
       36
       +
                   "type": "string",

     

       37
       37
       +
                   "description": "The album artist of the song.",

     

       38
       38
       +
                   "minLength": 1,

     

       39
       39
       +
                   "maxLength": 256

     

       40
       40
       +
                 },

     

       41
       41
       +
                 "appleMusicLink": {

     

       42
       42
       +
                   "type": "string",

     

       43
       43
       +
                   "description": "The Apple Music link of the song.",

     

       44
       44
       +
                   "format": "uri"

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "artist": {

     

       47
       47
       +
                   "type": "string",

     

       48
       48
       +
                   "description": "The artist of the song.",

     

       49
       49
       +
                   "minLength": 1,

     

       50
       50
       +
                   "maxLength": 256

     

       51
       51
       +
                 },

     

       52
       52
       +
                 "composer": {

     

       53
       53
       +
                   "type": "string",

     

       54
       54
       +
                   "description": "The composer of the song.",

     

       55
       55
       +
                   "maxLength": 256

     

       56
       56
       +
                 },

     

       57
       57
       +
                 "copyrightMessage": {

     

       58
       58
       +
                   "type": "string",

     

       59
       59
       +
                   "description": "The copyright message of the song.",

     

       60
       60
       +
                   "maxLength": 256

     

       61
       61
       +
                 },

     

       62
       62
       +
                 "createdAt": {

     

       63
       63
       +
                   "type": "string",

     

       64
       64
       +
                   "description": "The date when the song was created.",

     

       65
       65
       +
                   "format": "datetime"

     

       66
       66
       +
                 },

     

       67
       67
       +
                 "discNumber": {

     

       68
       68
       +
                   "type": "integer",

     

       69
       69
       +
                   "description": "The disc number of the song in the album.",

     

       70
       70
       +
                   "minimum": 1

     

       71
       71
       +
                 },

     

       72
       72
       +
                 "duration": {

     

       73
       73
       +
                   "type": "integer",

     

       74
       74
       +
                   "description": "The duration of the song in seconds.",

     

       75
       75
       +
                   "minimum": 1

     

       76
       76
       +
                 },

     

       77
       77
       +
                 "genre": {

     

       78
       78
       +
                   "type": "string",

     

       79
       79
       +
                   "description": "The genre of the song.",

     

       80
       80
       +
                   "minLength": 1,

     

       81
       81
       +
                   "maxLength": 256

     

       82
       82
       +
                 },

     

       83
       83
       +
                 "label": {

     

       84
       84
       +
                   "type": "string",

     

       85
       85
       +
                   "description": "The label of the song.",

     

       86
       86
       +
                   "maxLength": 256

     

       87
       87
       +
                 },

     

       88
       88
       +
                 "lyrics": {

     

       89
       89
       +
                   "type": "string",

     

       90
       90
       +
                   "description": "The lyrics of the song.",

     

       91
       91
       +
                   "maxLength": 10000

     

       92
       92
       +
                 },

     

       93
       93
       +
                 "mbid": {

     

       94
       94
       +
                   "type": "string",

     

       95
       95
       +
                   "description": "The MusicBrainz ID of the song."

     

       96
       96
       +
                 },

     

       97
       97
       +
                 "releaseDate": {

     

       98
       98
       +
                   "type": "string",

     

       99
       99
       +
                   "description": "The release date of the song.",

     

       100
       100
       +
                   "format": "datetime"

     

       101
       101
       +
                 },

     

       102
       102
       +
                 "spotifyLink": {

     

       103
       103
       +
                   "type": "string",

     

       104
       104
       +
                   "description": "The Spotify link of the song.",

     

       105
       105
       +
                   "format": "uri"

     

       106
       106
       +
                 },

     

       107
       107
       +
                 "tags": {

     

       108
       108
       +
                   "type": "array",

     

       109
       109
       +
                   "description": "The tags of the song.",

     

       110
       110
       +
                   "items": {

     

       111
       111
       +
                     "type": "string",

     

       112
       112
       +
                     "minLength": 1,

     

       113
       113
       +
                     "maxLength": 256

     

       114
       114
       +
                   }

     

       115
       115
       +
                 },

     

       116
       116
       +
                 "tidalLink": {

     

       117
       117
       +
                   "type": "string",

     

       118
       118
       +
                   "description": "The Tidal link of the song.",

     

       119
       119
       +
                   "format": "uri"

     

       120
       120
       +
                 },

     

       121
       121
       +
                 "title": {

     

       122
       122
       +
                   "type": "string",

     

       123
       123
       +
                   "description": "The title of the song.",

     

       124
       124
       +
                   "minLength": 1,

     

       125
       125
       +
                   "maxLength": 512

     

       126
       126
       +
                 },

     

       127
       127
       +
                 "trackNumber": {

     

       128
       128
       +
                   "type": "integer",

     

       129
       129
       +
                   "description": "The track number of the song in the album.",

     

       130
       130
       +
                   "minimum": 1

     

       131
       131
       +
                 },

     

       132
       132
       +
                 "wiki": {

     

       133
       133
       +
                   "type": "string",

     

       134
       134
       +
                   "description": "Informations about the song",

     

       135
       135
       +
                   "maxLength": 10000

     

       136
       136
       +
                 },

     

       137
       137
       +
                 "year": {

     

       138
       138
       +
                   "type": "integer",

     

       139
       139
       +
                   "description": "The year the song was released."

     

       140
       140
       +
                 },

     

       141
       141
       +
                 "youtubeLink": {

     

       142
       142
       +
                   "type": "string",

     

       143
       143
       +
                   "description": "The YouTube link of the song.",

     

       144
       144
       +
                   "format": "uri"

     

       145
       145
       +
                 }

     

       146
       146
       +
               }

     

       147
       147
       +
             }

     

       148
       148
       +
           }

     

       149
       149
       +
         }

     

       150
       150
       +
       }

+80

crates/jacquard-api/lexicons/app_rocksky_song_createSong.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.song.createSong",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Create a new song",

     

       8
       8
       +
             "input": {

     

       9
       9
       +
               "encoding": "application/json",

     

       10
       10
       +
               "schema": {

     

       11
       11
       +
                 "type": "object",

     

       12
       12
       +
                 "required": [

     

       13
       13
       +
                   "title",

     

       14
       14
       +
                   "artist",

     

       15
       15
       +
                   "album",

     

       16
       16
       +
                   "albumArtist"

     

       17
       17
       +
                 ],

     

       18
       18
       +
                 "properties": {

     

       19
       19
       +
                   "album": {

     

       20
       20
       +
                     "type": "string",

     

       21
       21
       +
                     "description": "The album of the song, if applicable"

     

       22
       22
       +
                   },

     

       23
       23
       +
                   "albumArt": {

     

       24
       24
       +
                     "type": "string",

     

       25
       25
       +
                     "description": "The URL of the album art for the song",

     

       26
       26
       +
                     "format": "uri"

     

       27
       27
       +
                   },

     

       28
       28
       +
                   "albumArtist": {

     

       29
       29
       +
                     "type": "string",

     

       30
       30
       +
                     "description": "The album artist of the song, if different from the main artist"

     

       31
       31
       +
                   },

     

       32
       32
       +
                   "artist": {

     

       33
       33
       +
                     "type": "string",

     

       34
       34
       +
                     "description": "The artist of the song"

     

       35
       35
       +
                   },

     

       36
       36
       +
                   "discNumber": {

     

       37
       37
       +
                     "type": "integer",

     

       38
       38
       +
                     "description": "The disc number of the song in the album, if applicable"

     

       39
       39
       +
                   },

     

       40
       40
       +
                   "duration": {

     

       41
       41
       +
                     "type": "integer",

     

       42
       42
       +
                     "description": "The duration of the song in seconds"

     

       43
       43
       +
                   },

     

       44
       44
       +
                   "lyrics": {

     

       45
       45
       +
                     "type": "string",

     

       46
       46
       +
                     "description": "The lyrics of the song, if available"

     

       47
       47
       +
                   },

     

       48
       48
       +
                   "mbId": {

     

       49
       49
       +
                     "type": "string",

     

       50
       50
       +
                     "description": "The MusicBrainz ID of the song, if available"

     

       51
       51
       +
                   },

     

       52
       52
       +
                   "releaseDate": {

     

       53
       53
       +
                     "type": "string",

     

       54
       54
       +
                     "description": "The release date of the song, formatted as YYYY-MM-DD"

     

       55
       55
       +
                   },

     

       56
       56
       +
                   "title": {

     

       57
       57
       +
                     "type": "string",

     

       58
       58
       +
                     "description": "The title of the song"

     

       59
       59
       +
                   },

     

       60
       60
       +
                   "trackNumber": {

     

       61
       61
       +
                     "type": "integer",

     

       62
       62
       +
                     "description": "The track number of the song in the album, if applicable"

     

       63
       63
       +
                   },

     

       64
       64
       +
                   "year": {

     

       65
       65
       +
                     "type": "integer",

     

       66
       66
       +
                     "description": "The year the song was released"

     

       67
       67
       +
                   }

     

       68
       68
       +
                 }

     

       69
       69
       +
               }

     

       70
       70
       +
             },

     

       71
       71
       +
             "output": {

     

       72
       72
       +
               "encoding": "application/json",

     

       73
       73
       +
               "schema": {

     

       74
       74
       +
                 "type": "ref",

     

       75
       75
       +
                 "ref": "app.rocksky.song.defs#songViewDetailed"

     

       76
       76
       +
               }

     

       77
       77
       +
             }

     

       78
       78
       +
           }

     

       79
       79
       +
         }

     

       80
       80
       +
       }

+158

crates/jacquard-api/lexicons/app_rocksky_song_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.song.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "songViewBasic": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "album": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The album of the song."

     

       11
       11
       +
               },

     

       12
       12
       +
               "albumArt": {

     

       13
       13
       +
                 "type": "string",

     

       14
       14
       +
                 "description": "The URL of the album art image.",

     

       15
       15
       +
                 "format": "uri"

     

       16
       16
       +
               },

     

       17
       17
       +
               "albumArtist": {

     

       18
       18
       +
                 "type": "string",

     

       19
       19
       +
                 "description": "The artist of the album the song belongs to."

     

       20
       20
       +
               },

     

       21
       21
       +
               "albumUri": {

     

       22
       22
       +
                 "type": "string",

     

       23
       23
       +
                 "description": "The URI of the album the song belongs to.",

     

       24
       24
       +
                 "format": "at-uri"

     

       25
       25
       +
               },

     

       26
       26
       +
               "artist": {

     

       27
       27
       +
                 "type": "string",

     

       28
       28
       +
                 "description": "The artist of the song."

     

       29
       29
       +
               },

     

       30
       30
       +
               "artistUri": {

     

       31
       31
       +
                 "type": "string",

     

       32
       32
       +
                 "description": "The URI of the artist of the song.",

     

       33
       33
       +
                 "format": "at-uri"

     

       34
       34
       +
               },

     

       35
       35
       +
               "createdAt": {

     

       36
       36
       +
                 "type": "string",

     

       37
       37
       +
                 "description": "The timestamp when the song was created.",

     

       38
       38
       +
                 "format": "datetime"

     

       39
       39
       +
               },

     

       40
       40
       +
               "discNumber": {

     

       41
       41
       +
                 "type": "integer",

     

       42
       42
       +
                 "description": "The disc number of the song in the album."

     

       43
       43
       +
               },

     

       44
       44
       +
               "duration": {

     

       45
       45
       +
                 "type": "integer",

     

       46
       46
       +
                 "description": "The duration of the song in milliseconds."

     

       47
       47
       +
               },

     

       48
       48
       +
               "id": {

     

       49
       49
       +
                 "type": "string",

     

       50
       50
       +
                 "description": "The unique identifier of the song."

     

       51
       51
       +
               },

     

       52
       52
       +
               "playCount": {

     

       53
       53
       +
                 "type": "integer",

     

       54
       54
       +
                 "description": "The number of times the song has been played.",

     

       55
       55
       +
                 "minimum": 0

     

       56
       56
       +
               },

     

       57
       57
       +
               "sha256": {

     

       58
       58
       +
                 "type": "string",

     

       59
       59
       +
                 "description": "The SHA256 hash of the song."

     

       60
       60
       +
               },

     

       61
       61
       +
               "title": {

     

       62
       62
       +
                 "type": "string",

     

       63
       63
       +
                 "description": "The title of the song."

     

       64
       64
       +
               },

     

       65
       65
       +
               "trackNumber": {

     

       66
       66
       +
                 "type": "integer",

     

       67
       67
       +
                 "description": "The track number of the song in the album."

     

       68
       68
       +
               },

     

       69
       69
       +
               "uniqueListeners": {

     

       70
       70
       +
                 "type": "integer",

     

       71
       71
       +
                 "description": "The number of unique listeners who have played the song.",

     

       72
       72
       +
                 "minimum": 0

     

       73
       73
       +
               },

     

       74
       74
       +
               "uri": {

     

       75
       75
       +
                 "type": "string",

     

       76
       76
       +
                 "description": "The URI of the song.",

     

       77
       77
       +
                 "format": "at-uri"

     

       78
       78
       +
               }

     

       79
       79
       +
             }

     

       80
       80
       +
           },

     

       81
       81
       +
           "songViewDetailed": {

     

       82
       82
       +
             "type": "object",

     

       83
       83
       +
             "properties": {

     

       84
       84
       +
               "album": {

     

       85
       85
       +
                 "type": "string",

     

       86
       86
       +
                 "description": "The album of the song."

     

       87
       87
       +
               },

     

       88
       88
       +
               "albumArt": {

     

       89
       89
       +
                 "type": "string",

     

       90
       90
       +
                 "description": "The URL of the album art image.",

     

       91
       91
       +
                 "format": "uri"

     

       92
       92
       +
               },

     

       93
       93
       +
               "albumArtist": {

     

       94
       94
       +
                 "type": "string",

     

       95
       95
       +
                 "description": "The artist of the album the song belongs to."

     

       96
       96
       +
               },

     

       97
       97
       +
               "albumUri": {

     

       98
       98
       +
                 "type": "string",

     

       99
       99
       +
                 "description": "The URI of the album the song belongs to.",

     

       100
       100
       +
                 "format": "at-uri"

     

       101
       101
       +
               },

     

       102
       102
       +
               "artist": {

     

       103
       103
       +
                 "type": "string",

     

       104
       104
       +
                 "description": "The artist of the song."

     

       105
       105
       +
               },

     

       106
       106
       +
               "artistUri": {

     

       107
       107
       +
                 "type": "string",

     

       108
       108
       +
                 "description": "The URI of the artist of the song.",

     

       109
       109
       +
                 "format": "at-uri"

     

       110
       110
       +
               },

     

       111
       111
       +
               "createdAt": {

     

       112
       112
       +
                 "type": "string",

     

       113
       113
       +
                 "description": "The timestamp when the song was created.",

     

       114
       114
       +
                 "format": "datetime"

     

       115
       115
       +
               },

     

       116
       116
       +
               "discNumber": {

     

       117
       117
       +
                 "type": "integer",

     

       118
       118
       +
                 "description": "The disc number of the song in the album."

     

       119
       119
       +
               },

     

       120
       120
       +
               "duration": {

     

       121
       121
       +
                 "type": "integer",

     

       122
       122
       +
                 "description": "The duration of the song in milliseconds."

     

       123
       123
       +
               },

     

       124
       124
       +
               "id": {

     

       125
       125
       +
                 "type": "string",

     

       126
       126
       +
                 "description": "The unique identifier of the song."

     

       127
       127
       +
               },

     

       128
       128
       +
               "playCount": {

     

       129
       129
       +
                 "type": "integer",

     

       130
       130
       +
                 "description": "The number of times the song has been played.",

     

       131
       131
       +
                 "minimum": 0

     

       132
       132
       +
               },

     

       133
       133
       +
               "sha256": {

     

       134
       134
       +
                 "type": "string",

     

       135
       135
       +
                 "description": "The SHA256 hash of the song."

     

       136
       136
       +
               },

     

       137
       137
       +
               "title": {

     

       138
       138
       +
                 "type": "string",

     

       139
       139
       +
                 "description": "The title of the song."

     

       140
       140
       +
               },

     

       141
       141
       +
               "trackNumber": {

     

       142
       142
       +
                 "type": "integer",

     

       143
       143
       +
                 "description": "The track number of the song in the album."

     

       144
       144
       +
               },

     

       145
       145
       +
               "uniqueListeners": {

     

       146
       146
       +
                 "type": "integer",

     

       147
       147
       +
                 "description": "The number of unique listeners who have played the song.",

     

       148
       148
       +
                 "minimum": 0

     

       149
       149
       +
               },

     

       150
       150
       +
               "uri": {

     

       151
       151
       +
                 "type": "string",

     

       152
       152
       +
                 "description": "The URI of the song.",

     

       153
       153
       +
                 "format": "at-uri"

     

       154
       154
       +
               }

     

       155
       155
       +
             }

     

       156
       156
       +
           }

     

       157
       157
       +
         }

     

       158
       158
       +
       }

+30

crates/jacquard-api/lexicons/app_rocksky_song_getSong.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.song.getSong",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get a song by its uri",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "uri"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "uri": {

     

       15
       15
       +
                   "type": "string",

     

       16
       16
       +
                   "description": "The unique identifier of the song to retrieve",

     

       17
       17
       +
                   "format": "at-uri"

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             },

     

       21
       21
       +
             "output": {

     

       22
       22
       +
               "encoding": "application/json",

     

       23
       23
       +
               "schema": {

     

       24
       24
       +
                 "type": "ref",

     

       25
       25
       +
                 "ref": "app.rocksky.song.defs#songViewDetailed"

     

       26
       26
       +
               }

     

       27
       27
       +
             }

     

       28
       28
       +
           }

     

       29
       29
       +
         }

     

       30
       30
       +
       }

+40

crates/jacquard-api/lexicons/app_rocksky_song_getSongs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.song.getSongs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get songs",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "limit": {

     

       12
       12
       +
                   "type": "integer",

     

       13
       13
       +
                   "description": "The maximum number of songs to return",

     

       14
       14
       +
                   "minimum": 1

     

       15
       15
       +
                 },

     

       16
       16
       +
                 "offset": {

     

       17
       17
       +
                   "type": "integer",

     

       18
       18
       +
                   "description": "The offset for pagination",

     

       19
       19
       +
                   "minimum": 0

     

       20
       20
       +
                 }

     

       21
       21
       +
               }

     

       22
       22
       +
             },

     

       23
       23
       +
             "output": {

     

       24
       24
       +
               "encoding": "application/json",

     

       25
       25
       +
               "schema": {

     

       26
       26
       +
                 "type": "object",

     

       27
       27
       +
                 "properties": {

     

       28
       28
       +
                   "songs": {

     

       29
       29
       +
                     "type": "array",

     

       30
       30
       +
                     "items": {

     

       31
       31
       +
                       "type": "ref",

     

       32
       32
       +
                       "ref": "app.rocksky.song.defs#songViewBasic"

     

       33
       33
       +
                     }

     

       34
       34
       +
                   }

     

       35
       35
       +
                 }

     

       36
       36
       +
               }

     

       37
       37
       +
             }

     

       38
       38
       +
           }

     

       39
       39
       +
         }

     

       40
       40
       +
       }

+35

crates/jacquard-api/lexicons/app_rocksky_spotify_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "spotifyTrackView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "album": {

     

       9
       9
       +
                 "type": "string",

     

       10
       10
       +
                 "description": "The name of the album."

     

       11
       11
       +
               },

     

       12
       12
       +
               "artist": {

     

       13
       13
       +
                 "type": "string",

     

       14
       14
       +
                 "description": "The name of the artist."

     

       15
       15
       +
               },

     

       16
       16
       +
               "duration": {

     

       17
       17
       +
                 "type": "integer",

     

       18
       18
       +
                 "description": "The duration of the track in milliseconds."

     

       19
       19
       +
               },

     

       20
       20
       +
               "id": {

     

       21
       21
       +
                 "type": "string",

     

       22
       22
       +
                 "description": "The unique identifier of the Spotify track."

     

       23
       23
       +
               },

     

       24
       24
       +
               "name": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "description": "The name of the track."

     

       27
       27
       +
               },

     

       28
       28
       +
               "previewUrl": {

     

       29
       29
       +
                 "type": "string",

     

       30
       30
       +
                 "description": "A URL to a preview of the track."

     

       31
       31
       +
               }

     

       32
       32
       +
             }

     

       33
       33
       +
           }

     

       34
       34
       +
         }

     

       35
       35
       +
       }

+27

crates/jacquard-api/lexicons/app_rocksky_spotify_getCurrentlyPlaying.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.getCurrentlyPlaying",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "description": "Get the currently playing track",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "properties": {

     

       11
       11
       +
                 "actor": {

     

       12
       12
       +
                   "type": "string",

     

       13
       13
       +
                   "description": "Handle or DID of the actor to retrieve the currently playing track for. If not provided, defaults to the current user.",

     

       14
       14
       +
                   "format": "at-identifier"

     

       15
       15
       +
                 }

     

       16
       16
       +
               }

     

       17
       17
       +
             },

     

       18
       18
       +
             "output": {

     

       19
       19
       +
               "encoding": "application/json",

     

       20
       20
       +
               "schema": {

     

       21
       21
       +
                 "type": "ref",

     

       22
       22
       +
                 "ref": "app.rocksky.player.defs#currentlyPlayingViewDetailed"

     

       23
       23
       +
               }

     

       24
       24
       +
             }

     

       25
       25
       +
           }

     

       26
       26
       +
         }

     

       27
       27
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_spotify_next.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.next",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Play the next track in the queue"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_spotify_pause.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.pause",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Pause the currently playing track"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_spotify_play.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.play",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Resume playback of the currently paused track"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+10

crates/jacquard-api/lexicons/app_rocksky_spotify_previous.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.previous",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Play the previous track in the queue"

     

       8
       8
       +
           }

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+22

crates/jacquard-api/lexicons/app_rocksky_spotify_seek.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.spotify.seek",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "procedure",

     

       7
       7
       +
             "description": "Seek to a specific position in the currently playing track",

     

       8
       8
       +
             "parameters": {

     

       9
       9
       +
               "type": "params",

     

       10
       10
       +
               "required": [

     

       11
       11
       +
                 "position"

     

       12
       12
       +
               ],

     

       13
       13
       +
               "properties": {

     

       14
       14
       +
                 "position": {

     

       15
       15
       +
                   "type": "integer",

     

       16
       16
       +
                   "description": "The position in seconds to seek to"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             }

     

       20
       20
       +
           }

     

       21
       21
       +
         }

     

       22
       22
       +
       }

+31

crates/jacquard-api/lexicons/app_rocksky_stats_defs.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.stats.defs",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "statsView": {

     

       6
       6
       +
             "type": "object",

     

       7
       7
       +
             "properties": {

     

       8
       8
       +
               "albums": {

     

       9
       9
       +
                 "type": "integer",

     

       10
       10
       +
                 "description": "The total number of unique albums scrobbled."

     

       11
       11
       +
               },

     

       12
       12
       +
               "artists": {

     

       13
       13
       +
                 "type": "integer",

     

       14
       14
       +
                 "description": "The total number of unique artists scrobbled."

     

       15
       15
       +
               },

     

       16
       16
       +
               "lovedTracks": {

     

       17
       17
       +
                 "type": "integer",

     

       18
       18
       +
                 "description": "The total number of tracks marked as loved."

     

       19
       19
       +
               },

     

       20
       20
       +
               "scrobbles": {

     

       21
       21
       +
                 "type": "integer",

     

       22
       22
       +
                 "description": "The total number of scrobbles."

     

       23
       23
       +
               },

     

       24
       24
       +
               "tracks": {

     

       25
       25
       +
                 "type": "integer",

     

       26
       26
       +
                 "description": "The total number of unique tracks scrobbled."

     

       27
       27
       +
               }

     

       28
       28
       +
             }

     

       29
       29
       +
           }

     

       30
       30
       +
         }

     

       31
       31
       +
       }

+29

crates/jacquard-api/lexicons/app_rocksky_stats_getStats.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "app.rocksky.stats.getStats",

     

       4
       4
       +
         "defs": {

     

       5
       5
       +
           "main": {

     

       6
       6
       +
             "type": "query",

     

       7
       7
       +
             "parameters": {

     

       8
       8
       +
               "type": "params",

     

       9
       9
       +
               "required": [

     

       10
       10
       +
                 "did"

     

       11
       11
       +
               ],

     

       12
       12
       +
               "properties": {

     

       13
       13
       +
                 "did": {

     

       14
       14
       +
                   "type": "string",

     

       15
       15
       +
                   "description": "The DID or handle of the user to get stats for.",

     

       16
       16
       +
                   "format": "at-identifier"

     

       17
       17
       +
                 }

     

       18
       18
       +
               }

     

       19
       19
       +
             },

     

       20
       20
       +
             "output": {

     

       21
       21
       +
               "encoding": "application/json",

     

       22
       22
       +
               "schema": {

     

       23
       23
       +
                 "type": "ref",

     

       24
       24
       +
                 "ref": "app.rocksky.stats.defs#statsView"

     

       25
       25
       +
               }

     

       26
       26
       +
             }

     

       27
       27
       +
           }

     

       28
       28
       +
         }

     

       29
       29
       +
       }

+106

crates/jacquard-api/lexicons/net_altq_aqfile.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "net.altq.aqfile",

     

       4
       4
       +
         "description": "A record for uploading and tracking binary blob files with metadata.",

     

       5
       5
       +
         "defs": {

     

       6
       6
       +
           "checksum": {

     

       7
       7
       +
             "type": "object",

     

       8
       8
       +
             "description": "Cryptographic checksum for integrity verification.",

     

       9
       9
       +
             "required": [

     

       10
       10
       +
               "algo",

     

       11
       11
       +
               "hash"

     

       12
       12
       +
             ],

     

       13
       13
       +
             "properties": {

     

       14
       14
       +
               "algo": {

     

       15
       15
       +
                 "type": "string",

     

       16
       16
       +
                 "description": "Hash algorithm name.",

     

       17
       17
       +
                 "maxLength": 32,

     

       18
       18
       +
                 "knownValues": [

     

       19
       19
       +
                   "sha256",

     

       20
       20
       +
                   "sha512",

     

       21
       21
       +
                   "blake3"

     

       22
       22
       +
                 ]

     

       23
       23
       +
               },

     

       24
       24
       +
               "hash": {

     

       25
       25
       +
                 "type": "string",

     

       26
       26
       +
                 "description": "Hex or base64 encoded digest produced by the algorithm.",

     

       27
       27
       +
                 "maxLength": 128

     

       28
       28
       +
               }

     

       29
       29
       +
             }

     

       30
       30
       +
           },

     

       31
       31
       +
           "file": {

     

       32
       32
       +
             "type": "object",

     

       33
       33
       +
             "description": "File metadata describing the uploaded blob.",

     

       34
       34
       +
             "required": [

     

       35
       35
       +
               "name",

     

       36
       36
       +
               "size"

     

       37
       37
       +
             ],

     

       38
       38
       +
             "properties": {

     

       39
       39
       +
               "mimeType": {

     

       40
       40
       +
                 "type": "string",

     

       41
       41
       +
                 "description": "MIME type, e.g. 'video/mp4'.",

     

       42
       42
       +
                 "maxLength": 255

     

       43
       43
       +
               },

     

       44
       44
       +
               "modifiedAt": {

     

       45
       45
       +
                 "type": "string",

     

       46
       46
       +
                 "description": "Client-side last-modified timestamp.",

     

       47
       47
       +
                 "format": "datetime"

     

       48
       48
       +
               },

     

       49
       49
       +
               "name": {

     

       50
       50
       +
                 "type": "string",

     

       51
       51
       +
                 "description": "User-visible filename.",

     

       52
       52
       +
                 "maxLength": 512

     

       53
       53
       +
               },

     

       54
       54
       +
               "size": {

     

       55
       55
       +
                 "type": "integer",

     

       56
       56
       +
                 "description": "File size in bytes.",

     

       57
       57
       +
                 "minimum": 0,

     

       58
       58
       +
                 "maximum": 1000000000

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
           },

     

       62
       62
       +
           "main": {

     

       63
       63
       +
             "type": "record",

     

       64
       64
       +
             "description": "A record representing an uploaded file blob with metadata.",

     

       65
       65
       +
             "key": "any",

     

       66
       66
       +
             "record": {

     

       67
       67
       +
               "type": "object",

     

       68
       68
       +
               "required": [

     

       69
       69
       +
                 "blob",

     

       70
       70
       +
                 "createdAt",

     

       71
       71
       +
                 "file"

     

       72
       72
       +
               ],

     

       73
       73
       +
               "properties": {

     

       74
       74
       +
                 "attribution": {

     

       75
       75
       +
                   "type": "string",

     

       76
       76
       +
                   "description": "Handle or DID of the account to attribute this upload to.",

     

       77
       77
       +
                   "format": "at-identifier"

     

       78
       78
       +
                 },

     

       79
       79
       +
                 "blob": {

     

       80
       80
       +
                   "type": "blob",

     

       81
       81
       +
                   "description": "The uploaded blob reference. Note: Individual PDS instances may enforce lower size limits.",

     

       82
       82
       +
                   "accept": [

     

       83
       83
       +
                     "*/*"

     

       84
       84
       +
                   ],

     

       85
       85
       +
                   "maxSize": 1000000000

     

       86
       86
       +
                 },

     

       87
       87
       +
                 "checksum": {

     

       88
       88
       +
                   "type": "ref",

     

       89
       89
       +
                   "description": "Optional cryptographic checksum for integrity verification.",

     

       90
       90
       +
                   "ref": "#checksum"

     

       91
       91
       +
                 },

     

       92
       92
       +
                 "createdAt": {

     

       93
       93
       +
                   "type": "string",

     

       94
       94
       +
                   "description": "Timestamp when this record was created.",

     

       95
       95
       +
                   "format": "datetime"

     

       96
       96
       +
                 },

     

       97
       97
       +
                 "file": {

     

       98
       98
       +
                   "type": "ref",

     

       99
       99
       +
                   "description": "Metadata about the file.",

     

       100
       100
       +
                   "ref": "#file"

     

       101
       101
       +
                 }

     

       102
       102
       +
               }

     

       103
       103
       +
             }

     

       104
       104
       +
           }

     

       105
       105
       +
         }

     

       106
       106
       +
       }

+73

crates/jacquard-api/src/app_rocksky/actor/get_actor_albums.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorAlbums

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorAlbums<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorAlbumsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.actor.getActorAlbums

     

       51
       51
       +
       pub struct GetActorAlbumsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorAlbumsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.actor.getActorAlbums";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetActorAlbumsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorAlbums<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.actor.getActorAlbums";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetActorAlbumsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.actor.getActorAlbums

     

       67
       67
       +
       pub struct GetActorAlbumsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorAlbumsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorAlbums";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetActorAlbums<'de>;

     

       72
       72
       +
           type Response = GetActorAlbumsResponse;

     

       73
       73
       +
       }

+75

crates/jacquard-api/src/app_rocksky/actor/get_actor_artists.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorArtists

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorArtists<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorArtistsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub artists: std::option::Option<

     

       47
       47
       +
               Vec<crate::app_rocksky::artist::ArtistViewBasic<'a>>,

     

       48
       48
       +
           >,

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       ///Response type for

     

       52
       52
       +
       ///app.rocksky.actor.getActorArtists

     

       53
       53
       +
       pub struct GetActorArtistsResponse;

     

       54
       54
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorArtistsResponse {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.actor.getActorArtists";

     

       56
       56
       +
           const ENCODING: &'static str = "application/json";

     

       57
       57
       +
           type Output<'de> = GetActorArtistsOutput<'de>;

     

       58
       58
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorArtists<'a> {

     

       62
       62
       +
           const NSID: &'static str = "app.rocksky.actor.getActorArtists";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Response = GetActorArtistsResponse;

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       ///Endpoint type for

     

       68
       68
       +
       ///app.rocksky.actor.getActorArtists

     

       69
       69
       +
       pub struct GetActorArtistsRequest;

     

       70
       70
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorArtistsRequest {

     

       71
       71
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorArtists";

     

       72
       72
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       73
       73
       +
           type Request<'de> = GetActorArtists<'de>;

     

       74
       74
       +
           type Response = GetActorArtistsResponse;

     

       75
       75
       +
       }

+73

crates/jacquard-api/src/app_rocksky/actor/get_actor_loved_songs.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorLovedSongs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorLovedSongs<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorLovedSongsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.actor.getActorLovedSongs

     

       51
       51
       +
       pub struct GetActorLovedSongsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorLovedSongsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.actor.getActorLovedSongs";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetActorLovedSongsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorLovedSongs<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.actor.getActorLovedSongs";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetActorLovedSongsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.actor.getActorLovedSongs

     

       67
       67
       +
       pub struct GetActorLovedSongsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorLovedSongsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorLovedSongs";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetActorLovedSongs<'de>;

     

       72
       72
       +
           type Response = GetActorLovedSongsResponse;

     

       73
       73
       +
       }

+75

crates/jacquard-api/src/app_rocksky/actor/get_actor_playlists.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorPlaylists

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorPlaylists<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorPlaylistsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub playlists: std::option::Option<

     

       47
       47
       +
               Vec<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>,

     

       48
       48
       +
           >,

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       ///Response type for

     

       52
       52
       +
       ///app.rocksky.actor.getActorPlaylists

     

       53
       53
       +
       pub struct GetActorPlaylistsResponse;

     

       54
       54
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorPlaylistsResponse {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.actor.getActorPlaylists";

     

       56
       56
       +
           const ENCODING: &'static str = "application/json";

     

       57
       57
       +
           type Output<'de> = GetActorPlaylistsOutput<'de>;

     

       58
       58
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorPlaylists<'a> {

     

       62
       62
       +
           const NSID: &'static str = "app.rocksky.actor.getActorPlaylists";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Response = GetActorPlaylistsResponse;

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       ///Endpoint type for

     

       68
       68
       +
       ///app.rocksky.actor.getActorPlaylists

     

       69
       69
       +
       pub struct GetActorPlaylistsRequest;

     

       70
       70
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorPlaylistsRequest {

     

       71
       71
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorPlaylists";

     

       72
       72
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       73
       73
       +
           type Request<'de> = GetActorPlaylists<'de>;

     

       74
       74
       +
           type Response = GetActorPlaylistsResponse;

     

       75
       75
       +
       }

+75

crates/jacquard-api/src/app_rocksky/actor/get_actor_scrobbles.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorScrobbles

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorScrobbles<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorScrobblesOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub scrobbles: std::option::Option<

     

       47
       47
       +
               Vec<crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>>,

     

       48
       48
       +
           >,

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       ///Response type for

     

       52
       52
       +
       ///app.rocksky.actor.getActorScrobbles

     

       53
       53
       +
       pub struct GetActorScrobblesResponse;

     

       54
       54
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorScrobblesResponse {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.actor.getActorScrobbles";

     

       56
       56
       +
           const ENCODING: &'static str = "application/json";

     

       57
       57
       +
           type Output<'de> = GetActorScrobblesOutput<'de>;

     

       58
       58
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorScrobbles<'a> {

     

       62
       62
       +
           const NSID: &'static str = "app.rocksky.actor.getActorScrobbles";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Response = GetActorScrobblesResponse;

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       ///Endpoint type for

     

       68
       68
       +
       ///app.rocksky.actor.getActorScrobbles

     

       69
       69
       +
       pub struct GetActorScrobblesRequest;

     

       70
       70
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorScrobblesRequest {

     

       71
       71
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorScrobbles";

     

       72
       72
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       73
       73
       +
           type Request<'de> = GetActorScrobbles<'de>;

     

       74
       74
       +
           type Response = GetActorScrobblesResponse;

     

       75
       75
       +
       }

+73

crates/jacquard-api/src/app_rocksky/actor/get_actor_songs.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getActorSongs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetActorSongs<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetActorSongsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub songs: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.actor.getActorSongs

     

       51
       51
       +
       pub struct GetActorSongsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetActorSongsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.actor.getActorSongs";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetActorSongsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorSongs<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.actor.getActorSongs";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetActorSongsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.actor.getActorSongs

     

       67
       67
       +
       pub struct GetActorSongsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetActorSongsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getActorSongs";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetActorSongs<'de>;

     

       72
       72
       +
           type Response = GetActorSongsResponse;

     

       73
       73
       +
       }

+67

crates/jacquard-api/src/app_rocksky/actor/get_profile.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.getProfile

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetProfile<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetProfileOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::actor::ProfileViewDetailed<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.actor.getProfile

     

       45
       45
       +
       pub struct GetProfileResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetProfileResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.actor.getProfile";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetProfileOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetProfile<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.actor.getProfile";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetProfileResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.actor.getProfile

     

       61
       61
       +
       pub struct GetProfileRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetProfileRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.actor.getProfile";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetProfile<'de>;

     

       66
       66
       +
           type Response = GetProfileResponse;

     

       67
       67
       +
       }

+96

crates/jacquard-api/src/app_rocksky/actor.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.actor.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_actor_albums;

     

       9
       9
       +
       pub mod get_actor_artists;

     

       10
       10
       +
       pub mod get_actor_loved_songs;

     

       11
       11
       +
       pub mod get_actor_playlists;

     

       12
       12
       +
       pub mod get_actor_scrobbles;

     

       13
       13
       +
       pub mod get_actor_songs;

     

       14
       14
       +
       pub mod get_profile;

     

       15
       15
       +
       

     

       16
       16
       +
       #[jacquard_derive::lexicon]

     

       17
       17
       +
       #[derive(

     

       18
       18
       +
           serde::Serialize,

     

       19
       19
       +
           serde::Deserialize,

     

       20
       20
       +
           Debug,

     

       21
       21
       +
           Clone,

     

       22
       22
       +
           PartialEq,

     

       23
       23
       +
           Eq,

     

       24
       24
       +
           jacquard_derive::IntoStatic,

     

       25
       25
       +
           Default

     

       26
       26
       +
       )]

     

       27
       27
       +
       #[serde(rename_all = "camelCase")]

     

       28
       28
       +
       pub struct ProfileViewBasic<'a> {

     

       29
       29
       +
           /// The URL of the actor's avatar image.

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[serde(borrow)]

     

       32
       32
       +
           pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       33
       33
       +
           /// The date and time when the actor was created.

     

       34
       34
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       35
       35
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       36
       36
       +
           /// The DID of the actor.

     

       37
       37
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub did: std::option::Option<jacquard_common::CowStr<'a>>,

     

       40
       40
       +
           /// The display name of the actor.

     

       41
       41
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       44
       44
       +
           /// The handle of the actor.

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub handle: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
       +
           /// The unique identifier of the actor.

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[serde(borrow)]

     

       51
       51
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       52
       52
       +
           /// The date and time when the actor was last updated.

     

       53
       53
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       54
       54
       +
           pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       #[jacquard_derive::lexicon]

     

       58
       58
       +
       #[derive(

     

       59
       59
       +
           serde::Serialize,

     

       60
       60
       +
           serde::Deserialize,

     

       61
       61
       +
           Debug,

     

       62
       62
       +
           Clone,

     

       63
       63
       +
           PartialEq,

     

       64
       64
       +
           Eq,

     

       65
       65
       +
           jacquard_derive::IntoStatic,

     

       66
       66
       +
           Default

     

       67
       67
       +
       )]

     

       68
       68
       +
       #[serde(rename_all = "camelCase")]

     

       69
       69
       +
       pub struct ProfileViewDetailed<'a> {

     

       70
       70
       +
           /// The URL of the actor's avatar image.

     

       71
       71
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       72
       72
       +
           #[serde(borrow)]

     

       73
       73
       +
           pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       74
       74
       +
           /// The date and time when the actor was created.

     

       75
       75
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       76
       76
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       77
       77
       +
           /// The DID of the actor.

     

       78
       78
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       79
       79
       +
           #[serde(borrow)]

     

       80
       80
       +
           pub did: std::option::Option<jacquard_common::CowStr<'a>>,

     

       81
       81
       +
           /// The display name of the actor.

     

       82
       82
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       83
       83
       +
           #[serde(borrow)]

     

       84
       84
       +
           pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       85
       85
       +
           /// The handle of the actor.

     

       86
       86
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       87
       87
       +
           #[serde(borrow)]

     

       88
       88
       +
           pub handle: std::option::Option<jacquard_common::CowStr<'a>>,

     

       89
       89
       +
           /// The unique identifier of the actor.

     

       90
       90
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       91
       91
       +
           #[serde(borrow)]

     

       92
       92
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       93
       93
       +
           /// The date and time when the actor was last updated.

     

       94
       94
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       95
       95
       +
           pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       96
       96
       +
       }

+66

crates/jacquard-api/src/app_rocksky/album/get_album.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.album.getAlbum

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetAlbum<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetAlbumOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::album::AlbumViewDetailed<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.album.getAlbum

     

       44
       44
       +
       pub struct GetAlbumResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetAlbumResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.album.getAlbum";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetAlbumOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbum<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.album.getAlbum";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetAlbumResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.album.getAlbum

     

       60
       60
       +
       pub struct GetAlbumRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbum";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetAlbum<'de>;

     

       65
       65
       +
           type Response = GetAlbumResponse;

     

       66
       66
       +
       }

+67

crates/jacquard-api/src/app_rocksky/album/get_album_tracks.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.album.getAlbumTracks

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetAlbumTracks<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic,

     

       34
       34
       +
           Default

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetAlbumTracksOutput<'a> {

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.album.getAlbumTracks

     

       45
       45
       +
       pub struct GetAlbumTracksResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetAlbumTracksResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.album.getAlbumTracks";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetAlbumTracksOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbumTracks<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.album.getAlbumTracks";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetAlbumTracksResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.album.getAlbumTracks

     

       61
       61
       +
       pub struct GetAlbumTracksRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumTracksRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbumTracks";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetAlbumTracks<'de>;

     

       66
       66
       +
           type Response = GetAlbumTracksResponse;

     

       67
       67
       +
       }

+71

crates/jacquard-api/src/app_rocksky/album/get_albums.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.album.getAlbums

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetAlbums {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       #[jacquard_derive::lexicon]

     

       30
       30
       +
       #[derive(

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           Debug,

     

       34
       34
       +
           Clone,

     

       35
       35
       +
           PartialEq,

     

       36
       36
       +
           Eq,

     

       37
       37
       +
           jacquard_derive::IntoStatic,

     

       38
       38
       +
           Default

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct GetAlbumsOutput<'a> {

     

       42
       42
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       ///Response type for

     

       48
       48
       +
       ///app.rocksky.album.getAlbums

     

       49
       49
       +
       pub struct GetAlbumsResponse;

     

       50
       50
       +
       impl jacquard_common::xrpc::XrpcResp for GetAlbumsResponse {

     

       51
       51
       +
           const NSID: &'static str = "app.rocksky.album.getAlbums";

     

       52
       52
       +
           const ENCODING: &'static str = "application/json";

     

       53
       53
       +
           type Output<'de> = GetAlbumsOutput<'de>;

     

       54
       54
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcRequest for GetAlbums {

     

       58
       58
       +
           const NSID: &'static str = "app.rocksky.album.getAlbums";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       60
       60
       +
           type Response = GetAlbumsResponse;

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       ///Endpoint type for

     

       64
       64
       +
       ///app.rocksky.album.getAlbums

     

       65
       65
       +
       pub struct GetAlbumsRequest;

     

       66
       66
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumsRequest {

     

       67
       67
       +
           const PATH: &'static str = "/xrpc/app.rocksky.album.getAlbums";

     

       68
       68
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       69
       69
       +
           type Request<'de> = GetAlbums;

     

       70
       70
       +
           type Response = GetAlbumsResponse;

     

       71
       71
       +
       }

+240

crates/jacquard-api/src/app_rocksky/album.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.album.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_album;

     

       9
       9
       +
       pub mod get_album_tracks;

     

       10
       10
       +
       pub mod get_albums;

     

       11
       11
       +
       

     

       12
       12
       +
       /// A declaration of an album.

     

       13
       13
       +
       #[jacquard_derive::lexicon]

     

       14
       14
       +
       #[derive(

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           Debug,

     

       18
       18
       +
           Clone,

     

       19
       19
       +
           PartialEq,

     

       20
       20
       +
           Eq,

     

       21
       21
       +
           jacquard_derive::IntoStatic,

     

       22
       22
       +
           bon::Builder

     

       23
       23
       +
       )]

     

       24
       24
       +
       #[serde(rename_all = "camelCase")]

     

       25
       25
       +
       pub struct Album<'a> {

     

       26
       26
       +
           /// The album art of the album.

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           #[builder(into)]

     

       29
       29
       +
           #[serde(borrow)]

     

       30
       30
       +
           pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,

     

       31
       31
       +
           /// The Apple Music link of the album.

     

       32
       32
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       33
       33
       +
           #[builder(into)]

     

       34
       34
       +
           #[serde(borrow)]

     

       35
       35
       +
           pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       36
       36
       +
           /// The artist of the album.

     

       37
       37
       +
           #[serde(borrow)]

     

       38
       38
       +
           #[builder(into)]

     

       39
       39
       +
           pub artist: jacquard_common::CowStr<'a>,

     

       40
       40
       +
           /// The date and time when the album was created.

     

       41
       41
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       42
       42
       +
           /// The duration of the album in seconds.

     

       43
       43
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       44
       44
       +
           #[builder(into)]

     

       45
       45
       +
           pub duration: Option<i64>,

     

       46
       46
       +
           /// The genre of the album.

     

       47
       47
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
       +
           #[builder(into)]

     

       49
       49
       +
           #[serde(borrow)]

     

       50
       50
       +
           pub genre: Option<jacquard_common::CowStr<'a>>,

     

       51
       51
       +
           /// The release date of the album.

     

       52
       52
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       53
       53
       +
           #[builder(into)]

     

       54
       54
       +
           pub release_date: Option<jacquard_common::types::string::Datetime>,

     

       55
       55
       +
           /// The Spotify link of the album.

     

       56
       56
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       57
       57
       +
           #[builder(into)]

     

       58
       58
       +
           #[serde(borrow)]

     

       59
       59
       +
           pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       60
       60
       +
           /// The tags of the album.

     

       61
       61
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
       +
           #[builder(into)]

     

       63
       63
       +
           #[serde(borrow)]

     

       64
       64
       +
           pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       65
       65
       +
           /// The tidal link of the album.

     

       66
       66
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       67
       67
       +
           #[builder(into)]

     

       68
       68
       +
           #[serde(borrow)]

     

       69
       69
       +
           pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       70
       70
       +
           /// The title of the album.

     

       71
       71
       +
           #[serde(borrow)]

     

       72
       72
       +
           #[builder(into)]

     

       73
       73
       +
           pub title: jacquard_common::CowStr<'a>,

     

       74
       74
       +
           /// The year the album was released.

     

       75
       75
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       76
       76
       +
           #[builder(into)]

     

       77
       77
       +
           pub year: Option<i64>,

     

       78
       78
       +
           /// The YouTube link of the album.

     

       79
       79
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       80
       80
       +
           #[builder(into)]

     

       81
       81
       +
           #[serde(borrow)]

     

       82
       82
       +
           pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       86
       86
       +
       #[derive(

     

       87
       87
       +
           serde::Serialize,

     

       88
       88
       +
           serde::Deserialize,

     

       89
       89
       +
           Debug,

     

       90
       90
       +
           Clone,

     

       91
       91
       +
           PartialEq,

     

       92
       92
       +
           Eq,

     

       93
       93
       +
           jacquard_derive::IntoStatic

     

       94
       94
       +
       )]

     

       95
       95
       +
       #[serde(rename_all = "camelCase")]

     

       96
       96
       +
       pub struct AlbumGetRecordOutput<'a> {

     

       97
       97
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       98
       98
       +
           #[serde(borrow)]

     

       99
       99
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       100
       100
       +
           #[serde(borrow)]

     

       101
       101
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       102
       102
       +
           #[serde(borrow)]

     

       103
       103
       +
           pub value: Album<'a>,

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

       106
       106
       +
       /// Marker type for deserializing records from this collection.

     

       107
       107
       +
       pub struct AlbumRecord;

     

       108
       108
       +
       impl jacquard_common::xrpc::XrpcResp for AlbumRecord {

     

       109
       109
       +
           const NSID: &'static str = "app.rocksky.album";

     

       110
       110
       +
           const ENCODING: &'static str = "application/json";

     

       111
       111
       +
           type Output<'de> = AlbumGetRecordOutput<'de>;

     

       112
       112
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       impl jacquard_common::types::collection::Collection for Album<'_> {

     

       116
       116
       +
           const NSID: &'static str = "app.rocksky.album";

     

       117
       117
       +
           type Record = AlbumRecord;

     

       118
       118
       +
       }

     

       119
       119
       +
       

     

       120
       120
       +
       impl From<AlbumGetRecordOutput<'_>> for Album<'_> {

     

       121
       121
       +
           fn from(output: AlbumGetRecordOutput<'_>) -> Self {

     

       122
       122
       +
               use jacquard_common::IntoStatic;

     

       123
       123
       +
               output.value.into_static()

     

       124
       124
       +
           }

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       #[jacquard_derive::lexicon]

     

       128
       128
       +
       #[derive(

     

       129
       129
       +
           serde::Serialize,

     

       130
       130
       +
           serde::Deserialize,

     

       131
       131
       +
           Debug,

     

       132
       132
       +
           Clone,

     

       133
       133
       +
           PartialEq,

     

       134
       134
       +
           Eq,

     

       135
       135
       +
           jacquard_derive::IntoStatic,

     

       136
       136
       +
           Default

     

       137
       137
       +
       )]

     

       138
       138
       +
       #[serde(rename_all = "camelCase")]

     

       139
       139
       +
       pub struct AlbumViewBasic<'a> {

     

       140
       140
       +
           /// The URL of the album art image.

     

       141
       141
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       142
       142
       +
           #[serde(borrow)]

     

       143
       143
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       144
       144
       +
           /// The artist of the album.

     

       145
       145
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       146
       146
       +
           #[serde(borrow)]

     

       147
       147
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       148
       148
       +
           /// The URI of the album's artist.

     

       149
       149
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       150
       150
       +
           #[serde(borrow)]

     

       151
       151
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       152
       152
       +
           /// The unique identifier of the album.

     

       153
       153
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       154
       154
       +
           #[serde(borrow)]

     

       155
       155
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       156
       156
       +
           /// The number of times the album has been played.

     

       157
       157
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       158
       158
       +
           pub play_count: std::option::Option<i64>,

     

       159
       159
       +
           /// The release date of the album.

     

       160
       160
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       161
       161
       +
           #[serde(borrow)]

     

       162
       162
       +
           pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,

     

       163
       163
       +
           /// The SHA256 hash of the album.

     

       164
       164
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       165
       165
       +
           #[serde(borrow)]

     

       166
       166
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       167
       167
       +
           /// The title of the album.

     

       168
       168
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       169
       169
       +
           #[serde(borrow)]

     

       170
       170
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       171
       171
       +
           /// The number of unique listeners who have played the album.

     

       172
       172
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       173
       173
       +
           pub unique_listeners: std::option::Option<i64>,

     

       174
       174
       +
           /// The URI of the album.

     

       175
       175
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       176
       176
       +
           #[serde(borrow)]

     

       177
       177
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       178
       178
       +
           /// The year the album was released.

     

       179
       179
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       180
       180
       +
           pub year: std::option::Option<i64>,

     

       181
       181
       +
       }

     

       182
       182
       +
       

     

       183
       183
       +
       #[jacquard_derive::lexicon]

     

       184
       184
       +
       #[derive(

     

       185
       185
       +
           serde::Serialize,

     

       186
       186
       +
           serde::Deserialize,

     

       187
       187
       +
           Debug,

     

       188
       188
       +
           Clone,

     

       189
       189
       +
           PartialEq,

     

       190
       190
       +
           Eq,

     

       191
       191
       +
           jacquard_derive::IntoStatic,

     

       192
       192
       +
           Default

     

       193
       193
       +
       )]

     

       194
       194
       +
       #[serde(rename_all = "camelCase")]

     

       195
       195
       +
       pub struct AlbumViewDetailed<'a> {

     

       196
       196
       +
           /// The URL of the album art image.

     

       197
       197
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       198
       198
       +
           #[serde(borrow)]

     

       199
       199
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       200
       200
       +
           /// The artist of the album.

     

       201
       201
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       202
       202
       +
           #[serde(borrow)]

     

       203
       203
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       204
       204
       +
           /// The URI of the album's artist.

     

       205
       205
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       206
       206
       +
           #[serde(borrow)]

     

       207
       207
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       208
       208
       +
           /// The unique identifier of the album.

     

       209
       209
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       210
       210
       +
           #[serde(borrow)]

     

       211
       211
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       212
       212
       +
           /// The number of times the album has been played.

     

       213
       213
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       214
       214
       +
           pub play_count: std::option::Option<i64>,

     

       215
       215
       +
           /// The release date of the album.

     

       216
       216
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       217
       217
       +
           #[serde(borrow)]

     

       218
       218
       +
           pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,

     

       219
       219
       +
           /// The SHA256 hash of the album.

     

       220
       220
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       221
       221
       +
           #[serde(borrow)]

     

       222
       222
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       223
       223
       +
           /// The title of the album.

     

       224
       224
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       225
       225
       +
           #[serde(borrow)]

     

       226
       226
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       227
       227
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       228
       228
       +
           #[serde(borrow)]

     

       229
       229
       +
           pub tracks: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       230
       230
       +
           /// The number of unique listeners who have played the album.

     

       231
       231
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       232
       232
       +
           pub unique_listeners: std::option::Option<i64>,

     

       233
       233
       +
           /// The URI of the album.

     

       234
       234
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       235
       235
       +
           #[serde(borrow)]

     

       236
       236
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       237
       237
       +
           /// The year the album was released.

     

       238
       238
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       239
       239
       +
           pub year: std::option::Option<i64>,

     

       240
       240
       +
       }

+75

crates/jacquard-api/src/app_rocksky/apikey/create_apikey.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.apikey.createApikey

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct CreateApikey<'a> {

     

       21
       21
       +
           /// A description for the API key.

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
           /// The name of the API key.

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub name: jacquard_common::CowStr<'a>,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       #[jacquard_derive::lexicon]

     

       31
       31
       +
       #[derive(

     

       32
       32
       +
           serde::Serialize,

     

       33
       33
       +
           serde::Deserialize,

     

       34
       34
       +
           Debug,

     

       35
       35
       +
           Clone,

     

       36
       36
       +
           PartialEq,

     

       37
       37
       +
           Eq,

     

       38
       38
       +
           jacquard_derive::IntoStatic

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct CreateApikeyOutput<'a> {

     

       42
       42
       +
           #[serde(flatten)]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub value: jacquard_common::types::value::Data<'a>,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       ///Response type for

     

       48
       48
       +
       ///app.rocksky.apikey.createApikey

     

       49
       49
       +
       pub struct CreateApikeyResponse;

     

       50
       50
       +
       impl jacquard_common::xrpc::XrpcResp for CreateApikeyResponse {

     

       51
       51
       +
           const NSID: &'static str = "app.rocksky.apikey.createApikey";

     

       52
       52
       +
           const ENCODING: &'static str = "application/json";

     

       53
       53
       +
           type Output<'de> = CreateApikeyOutput<'de>;

     

       54
       54
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for CreateApikey<'a> {

     

       58
       58
       +
           const NSID: &'static str = "app.rocksky.apikey.createApikey";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       60
       60
       +
               "application/json",

     

       61
       61
       +
           );

     

       62
       62
       +
           type Response = CreateApikeyResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.apikey.createApikey

     

       67
       67
       +
       pub struct CreateApikeyRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for CreateApikeyRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.apikey.createApikey";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       71
       71
       +
               "application/json",

     

       72
       72
       +
           );

     

       73
       73
       +
           type Request<'de> = CreateApikey<'de>;

     

       74
       74
       +
           type Response = CreateApikeyResponse;

     

       75
       75
       +
       }

+69

crates/jacquard-api/src/app_rocksky/apikey/get_apikeys.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.apikey.getApikeys

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetApikeys {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           pub limit: std::option::Option<i64>,

     

       23
       23
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
       +
           pub offset: std::option::Option<i64>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic,

     

       36
       36
       +
           Default

     

       37
       37
       +
       )]

     

       38
       38
       +
       #[serde(rename_all = "camelCase")]

     

       39
       39
       +
       pub struct GetApikeysOutput<'a> {

     

       40
       40
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
       +
           #[serde(borrow)]

     

       42
       42
       +
           pub api_keys: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       ///Response type for

     

       46
       46
       +
       ///app.rocksky.apikey.getApikeys

     

       47
       47
       +
       pub struct GetApikeysResponse;

     

       48
       48
       +
       impl jacquard_common::xrpc::XrpcResp for GetApikeysResponse {

     

       49
       49
       +
           const NSID: &'static str = "app.rocksky.apikey.getApikeys";

     

       50
       50
       +
           const ENCODING: &'static str = "application/json";

     

       51
       51
       +
           type Output<'de> = GetApikeysOutput<'de>;

     

       52
       52
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       impl jacquard_common::xrpc::XrpcRequest for GetApikeys {

     

       56
       56
       +
           const NSID: &'static str = "app.rocksky.apikey.getApikeys";

     

       57
       57
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       58
       58
       +
           type Response = GetApikeysResponse;

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       ///Endpoint type for

     

       62
       62
       +
       ///app.rocksky.apikey.getApikeys

     

       63
       63
       +
       pub struct GetApikeysRequest;

     

       64
       64
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetApikeysRequest {

     

       65
       65
       +
           const PATH: &'static str = "/xrpc/app.rocksky.apikey.getApikeys";

     

       66
       66
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       67
       67
       +
           type Request<'de> = GetApikeys;

     

       68
       68
       +
           type Response = GetApikeysResponse;

     

       69
       69
       +
       }

+83

crates/jacquard-api/src/app_rocksky/apikey/remove_apikey.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.apikey.removeApikey

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct RemoveApikeyParams<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub id: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct RemoveApikeyOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: jacquard_common::types::value::Data<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       /// XRPC request marker type

     

       44
       44
       +
       #[derive(

     

       45
       45
       +
           Debug,

     

       46
       46
       +
           Clone,

     

       47
       47
       +
           Copy,

     

       48
       48
       +
           PartialEq,

     

       49
       49
       +
           Eq,

     

       50
       50
       +
           serde::Serialize,

     

       51
       51
       +
           serde::Deserialize,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       53
       53
       +
       )]

     

       54
       54
       +
       pub struct RemoveApikey;

     

       55
       55
       +
       ///Response type for

     

       56
       56
       +
       ///app.rocksky.apikey.removeApikey

     

       57
       57
       +
       pub struct RemoveApikeyResponse;

     

       58
       58
       +
       impl jacquard_common::xrpc::XrpcResp for RemoveApikeyResponse {

     

       59
       59
       +
           const NSID: &'static str = "app.rocksky.apikey.removeApikey";

     

       60
       60
       +
           const ENCODING: &'static str = "application/json";

     

       61
       61
       +
           type Output<'de> = RemoveApikeyOutput<'de>;

     

       62
       62
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcRequest for RemoveApikey {

     

       66
       66
       +
           const NSID: &'static str = "app.rocksky.apikey.removeApikey";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Response = RemoveApikeyResponse;

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       ///Endpoint type for

     

       74
       74
       +
       ///app.rocksky.apikey.removeApikey

     

       75
       75
       +
       pub struct RemoveApikeyRequest;

     

       76
       76
       +
       impl jacquard_common::xrpc::XrpcEndpoint for RemoveApikeyRequest {

     

       77
       77
       +
           const PATH: &'static str = "/xrpc/app.rocksky.apikey.removeApikey";

     

       78
       78
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       79
       79
       +
               "application/json",

     

       80
       80
       +
           );

     

       81
       81
       +
           type Request<'de> = RemoveApikey;

     

       82
       82
       +
           type Response = RemoveApikeyResponse;

     

       83
       83
       +
       }

+78

crates/jacquard-api/src/app_rocksky/apikey/update_apikey.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.apikey.updateApikey

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct UpdateApikey<'a> {

     

       21
       21
       +
           /// A new description for the API key.

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
           /// The ID of the API key to update.

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub id: jacquard_common::CowStr<'a>,

     

       28
       28
       +
           /// The new name of the API key.

     

       29
       29
       +
           #[serde(borrow)]

     

       30
       30
       +
           pub name: jacquard_common::CowStr<'a>,

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       #[jacquard_derive::lexicon]

     

       34
       34
       +
       #[derive(

     

       35
       35
       +
           serde::Serialize,

     

       36
       36
       +
           serde::Deserialize,

     

       37
       37
       +
           Debug,

     

       38
       38
       +
           Clone,

     

       39
       39
       +
           PartialEq,

     

       40
       40
       +
           Eq,

     

       41
       41
       +
           jacquard_derive::IntoStatic

     

       42
       42
       +
       )]

     

       43
       43
       +
       #[serde(rename_all = "camelCase")]

     

       44
       44
       +
       pub struct UpdateApikeyOutput<'a> {

     

       45
       45
       +
           #[serde(flatten)]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub value: jacquard_common::types::value::Data<'a>,

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       ///Response type for

     

       51
       51
       +
       ///app.rocksky.apikey.updateApikey

     

       52
       52
       +
       pub struct UpdateApikeyResponse;

     

       53
       53
       +
       impl jacquard_common::xrpc::XrpcResp for UpdateApikeyResponse {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.apikey.updateApikey";

     

       55
       55
       +
           const ENCODING: &'static str = "application/json";

     

       56
       56
       +
           type Output<'de> = UpdateApikeyOutput<'de>;

     

       57
       57
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for UpdateApikey<'a> {

     

       61
       61
       +
           const NSID: &'static str = "app.rocksky.apikey.updateApikey";

     

       62
       62
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       63
       63
       +
               "application/json",

     

       64
       64
       +
           );

     

       65
       65
       +
           type Response = UpdateApikeyResponse;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       ///Endpoint type for

     

       69
       69
       +
       ///app.rocksky.apikey.updateApikey

     

       70
       70
       +
       pub struct UpdateApikeyRequest;

     

       71
       71
       +
       impl jacquard_common::xrpc::XrpcEndpoint for UpdateApikeyRequest {

     

       72
       72
       +
           const PATH: &'static str = "/xrpc/app.rocksky.apikey.updateApikey";

     

       73
       73
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       74
       74
       +
               "application/json",

     

       75
       75
       +
           );

     

       76
       76
       +
           type Request<'de> = UpdateApikey<'de>;

     

       77
       77
       +
           type Response = UpdateApikeyResponse;

     

       78
       78
       +
       }

+41

crates/jacquard-api/src/app_rocksky/apikey.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.apikey.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod create_apikey;

     

       9
       9
       +
       pub mod get_apikeys;

     

       10
       10
       +
       pub mod remove_apikey;

     

       11
       11
       +
       pub mod update_apikey;

     

       12
       12
       +
       

     

       13
       13
       +
       #[jacquard_derive::lexicon]

     

       14
       14
       +
       #[derive(

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           Debug,

     

       18
       18
       +
           Clone,

     

       19
       19
       +
           PartialEq,

     

       20
       20
       +
           Eq,

     

       21
       21
       +
           jacquard_derive::IntoStatic,

     

       22
       22
       +
           Default

     

       23
       23
       +
       )]

     

       24
       24
       +
       #[serde(rename_all = "camelCase")]

     

       25
       25
       +
       pub struct ApiKeyView<'a> {

     

       26
       26
       +
           /// The date and time when the API key was created.

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       29
       29
       +
           /// A description for the API key.

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[serde(borrow)]

     

       32
       32
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       33
       33
       +
           /// The unique identifier of the API key.

     

       34
       34
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       35
       35
       +
           #[serde(borrow)]

     

       36
       36
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       37
       37
       +
           /// The name of the API key.

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       41
       41
       +
       }

+66

crates/jacquard-api/src/app_rocksky/artist/get_artist.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.artist.getArtist

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetArtist<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetArtistOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::artist::ArtistViewDetailed<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.artist.getArtist

     

       44
       44
       +
       pub struct GetArtistResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetArtistResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.artist.getArtist";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetArtistOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtist<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.artist.getArtist";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetArtistResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.artist.getArtist

     

       60
       60
       +
       pub struct GetArtistRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetArtistRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtist";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetArtist<'de>;

     

       65
       65
       +
           type Response = GetArtistResponse;

     

       66
       66
       +
       }

+67

crates/jacquard-api/src/app_rocksky/artist/get_artist_albums.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.artist.getArtistAlbums

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetArtistAlbums<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic,

     

       34
       34
       +
           Default

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetArtistAlbumsOutput<'a> {

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub albums: std::option::Option<Vec<crate::app_rocksky::album::AlbumViewBasic<'a>>>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.artist.getArtistAlbums

     

       45
       45
       +
       pub struct GetArtistAlbumsResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetArtistAlbumsResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.artist.getArtistAlbums";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetArtistAlbumsOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistAlbums<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.artist.getArtistAlbums";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetArtistAlbumsResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.artist.getArtistAlbums

     

       61
       61
       +
       pub struct GetArtistAlbumsRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetArtistAlbumsRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtistAlbums";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetArtistAlbums<'de>;

     

       66
       66
       +
           type Response = GetArtistAlbumsResponse;

     

       67
       67
       +
       }

+74

crates/jacquard-api/src/app_rocksky/artist/get_artist_tracks.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.artist.getArtistTracks

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetArtistTracks<'a> {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           #[serde(borrow)]

     

       29
       29
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       #[jacquard_derive::lexicon]

     

       33
       33
       +
       #[derive(

     

       34
       34
       +
           serde::Serialize,

     

       35
       35
       +
           serde::Deserialize,

     

       36
       36
       +
           Debug,

     

       37
       37
       +
           Clone,

     

       38
       38
       +
           PartialEq,

     

       39
       39
       +
           Eq,

     

       40
       40
       +
           jacquard_derive::IntoStatic,

     

       41
       41
       +
           Default

     

       42
       42
       +
       )]

     

       43
       43
       +
       #[serde(rename_all = "camelCase")]

     

       44
       44
       +
       pub struct GetArtistTracksOutput<'a> {

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       ///Response type for

     

       51
       51
       +
       ///app.rocksky.artist.getArtistTracks

     

       52
       52
       +
       pub struct GetArtistTracksResponse;

     

       53
       53
       +
       impl jacquard_common::xrpc::XrpcResp for GetArtistTracksResponse {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.artist.getArtistTracks";

     

       55
       55
       +
           const ENCODING: &'static str = "application/json";

     

       56
       56
       +
           type Output<'de> = GetArtistTracksOutput<'de>;

     

       57
       57
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistTracks<'a> {

     

       61
       61
       +
           const NSID: &'static str = "app.rocksky.artist.getArtistTracks";

     

       62
       62
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       63
       63
       +
           type Response = GetArtistTracksResponse;

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

       66
       66
       +
       ///Endpoint type for

     

       67
       67
       +
       ///app.rocksky.artist.getArtistTracks

     

       68
       68
       +
       pub struct GetArtistTracksRequest;

     

       69
       69
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetArtistTracksRequest {

     

       70
       70
       +
           const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtistTracks";

     

       71
       71
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       72
       72
       +
           type Request<'de> = GetArtistTracks<'de>;

     

       73
       73
       +
           type Response = GetArtistTracksResponse;

     

       74
       74
       +
       }

+73

crates/jacquard-api/src/app_rocksky/artist/get_artists.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.artist.getArtists

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetArtists {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       #[jacquard_derive::lexicon]

     

       30
       30
       +
       #[derive(

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           Debug,

     

       34
       34
       +
           Clone,

     

       35
       35
       +
           PartialEq,

     

       36
       36
       +
           Eq,

     

       37
       37
       +
           jacquard_derive::IntoStatic,

     

       38
       38
       +
           Default

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct GetArtistsOutput<'a> {

     

       42
       42
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub artists: std::option::Option<

     

       45
       45
       +
               Vec<crate::app_rocksky::artist::ArtistViewBasic<'a>>,

     

       46
       46
       +
           >,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.artist.getArtists

     

       51
       51
       +
       pub struct GetArtistsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetArtistsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.artist.getArtists";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetArtistsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl jacquard_common::xrpc::XrpcRequest for GetArtists {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.artist.getArtists";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetArtistsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.artist.getArtists

     

       67
       67
       +
       pub struct GetArtistsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetArtistsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.artist.getArtists";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetArtists;

     

       72
       72
       +
           type Response = GetArtistsResponse;

     

       73
       73
       +
       }

+185

crates/jacquard-api/src/app_rocksky/artist.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.artist.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_artist;

     

       9
       9
       +
       pub mod get_artist_albums;

     

       10
       10
       +
       pub mod get_artist_tracks;

     

       11
       11
       +
       pub mod get_artists;

     

       12
       12
       +
       

     

       13
       13
       +
       /// A declaration of an artist.

     

       14
       14
       +
       #[jacquard_derive::lexicon]

     

       15
       15
       +
       #[derive(

     

       16
       16
       +
           serde::Serialize,

     

       17
       17
       +
           serde::Deserialize,

     

       18
       18
       +
           Debug,

     

       19
       19
       +
           Clone,

     

       20
       20
       +
           PartialEq,

     

       21
       21
       +
           Eq,

     

       22
       22
       +
           jacquard_derive::IntoStatic,

     

       23
       23
       +
           bon::Builder

     

       24
       24
       +
       )]

     

       25
       25
       +
       #[serde(rename_all = "camelCase")]

     

       26
       26
       +
       pub struct Artist<'a> {

     

       27
       27
       +
           /// The biography of the artist.

     

       28
       28
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       29
       29
       +
           #[builder(into)]

     

       30
       30
       +
           #[serde(borrow)]

     

       31
       31
       +
           pub bio: Option<jacquard_common::CowStr<'a>>,

     

       32
       32
       +
           /// The birth date of the artist.

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           #[builder(into)]

     

       35
       35
       +
           pub born: Option<jacquard_common::types::string::Datetime>,

     

       36
       36
       +
           /// The birth place of the artist.

     

       37
       37
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       38
       38
       +
           #[builder(into)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub born_in: Option<jacquard_common::CowStr<'a>>,

     

       41
       41
       +
           /// The date when the artist was created.

     

       42
       42
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       43
       43
       +
           /// The death date of the artist.

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[builder(into)]

     

       46
       46
       +
           pub died: Option<jacquard_common::types::string::Datetime>,

     

       47
       47
       +
           /// The name of the artist.

     

       48
       48
       +
           #[serde(borrow)]

     

       49
       49
       +
           #[builder(into)]

     

       50
       50
       +
           pub name: jacquard_common::CowStr<'a>,

     

       51
       51
       +
           /// The picture of the artist.

     

       52
       52
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       53
       53
       +
           #[builder(into)]

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           pub picture: Option<jacquard_common::types::blob::Blob<'a>>,

     

       56
       56
       +
           /// The tags of the artist.

     

       57
       57
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
       +
           #[builder(into)]

     

       59
       59
       +
           #[serde(borrow)]

     

       60
       60
       +
           pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       64
       64
       +
       #[derive(

     

       65
       65
       +
           serde::Serialize,

     

       66
       66
       +
           serde::Deserialize,

     

       67
       67
       +
           Debug,

     

       68
       68
       +
           Clone,

     

       69
       69
       +
           PartialEq,

     

       70
       70
       +
           Eq,

     

       71
       71
       +
           jacquard_derive::IntoStatic

     

       72
       72
       +
       )]

     

       73
       73
       +
       #[serde(rename_all = "camelCase")]

     

       74
       74
       +
       pub struct ArtistGetRecordOutput<'a> {

     

       75
       75
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       76
       76
       +
           #[serde(borrow)]

     

       77
       77
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       78
       78
       +
           #[serde(borrow)]

     

       79
       79
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       80
       80
       +
           #[serde(borrow)]

     

       81
       81
       +
           pub value: Artist<'a>,

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       /// Marker type for deserializing records from this collection.

     

       85
       85
       +
       pub struct ArtistRecord;

     

       86
       86
       +
       impl jacquard_common::xrpc::XrpcResp for ArtistRecord {

     

       87
       87
       +
           const NSID: &'static str = "app.rocksky.artist";

     

       88
       88
       +
           const ENCODING: &'static str = "application/json";

     

       89
       89
       +
           type Output<'de> = ArtistGetRecordOutput<'de>;

     

       90
       90
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       impl jacquard_common::types::collection::Collection for Artist<'_> {

     

       94
       94
       +
           const NSID: &'static str = "app.rocksky.artist";

     

       95
       95
       +
           type Record = ArtistRecord;

     

       96
       96
       +
       }

     

       97
       97
       +
       

     

       98
       98
       +
       impl From<ArtistGetRecordOutput<'_>> for Artist<'_> {

     

       99
       99
       +
           fn from(output: ArtistGetRecordOutput<'_>) -> Self {

     

       100
       100
       +
               use jacquard_common::IntoStatic;

     

       101
       101
       +
               output.value.into_static()

     

       102
       102
       +
           }

     

       103
       103
       +
       }

     

       104
       104
       +
       

     

       105
       105
       +
       #[jacquard_derive::lexicon]

     

       106
       106
       +
       #[derive(

     

       107
       107
       +
           serde::Serialize,

     

       108
       108
       +
           serde::Deserialize,

     

       109
       109
       +
           Debug,

     

       110
       110
       +
           Clone,

     

       111
       111
       +
           PartialEq,

     

       112
       112
       +
           Eq,

     

       113
       113
       +
           jacquard_derive::IntoStatic,

     

       114
       114
       +
           Default

     

       115
       115
       +
       )]

     

       116
       116
       +
       #[serde(rename_all = "camelCase")]

     

       117
       117
       +
       pub struct ArtistViewBasic<'a> {

     

       118
       118
       +
           /// The unique identifier of the artist.

     

       119
       119
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       120
       120
       +
           #[serde(borrow)]

     

       121
       121
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       122
       122
       +
           /// The name of the artist.

     

       123
       123
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       124
       124
       +
           #[serde(borrow)]

     

       125
       125
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       126
       126
       +
           /// The picture of the artist.

     

       127
       127
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       128
       128
       +
           #[serde(borrow)]

     

       129
       129
       +
           pub picture: std::option::Option<jacquard_common::CowStr<'a>>,

     

       130
       130
       +
           /// The number of times the artist has been played.

     

       131
       131
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       132
       132
       +
           pub play_count: std::option::Option<i64>,

     

       133
       133
       +
           /// The SHA256 hash of the artist.

     

       134
       134
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       135
       135
       +
           #[serde(borrow)]

     

       136
       136
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       137
       137
       +
           /// The number of unique listeners who have played the artist.

     

       138
       138
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       139
       139
       +
           pub unique_listeners: std::option::Option<i64>,

     

       140
       140
       +
           /// The URI of the artist.

     

       141
       141
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       142
       142
       +
           #[serde(borrow)]

     

       143
       143
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       144
       144
       +
       }

     

       145
       145
       +
       

     

       146
       146
       +
       #[jacquard_derive::lexicon]

     

       147
       147
       +
       #[derive(

     

       148
       148
       +
           serde::Serialize,

     

       149
       149
       +
           serde::Deserialize,

     

       150
       150
       +
           Debug,

     

       151
       151
       +
           Clone,

     

       152
       152
       +
           PartialEq,

     

       153
       153
       +
           Eq,

     

       154
       154
       +
           jacquard_derive::IntoStatic,

     

       155
       155
       +
           Default

     

       156
       156
       +
       )]

     

       157
       157
       +
       #[serde(rename_all = "camelCase")]

     

       158
       158
       +
       pub struct ArtistViewDetailed<'a> {

     

       159
       159
       +
           /// The unique identifier of the artist.

     

       160
       160
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       161
       161
       +
           #[serde(borrow)]

     

       162
       162
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       163
       163
       +
           /// The name of the artist.

     

       164
       164
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       165
       165
       +
           #[serde(borrow)]

     

       166
       166
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       167
       167
       +
           /// The picture of the artist.

     

       168
       168
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       169
       169
       +
           #[serde(borrow)]

     

       170
       170
       +
           pub picture: std::option::Option<jacquard_common::CowStr<'a>>,

     

       171
       171
       +
           /// The number of times the artist has been played.

     

       172
       172
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       173
       173
       +
           pub play_count: std::option::Option<i64>,

     

       174
       174
       +
           /// The SHA256 hash of the artist.

     

       175
       175
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       176
       176
       +
           #[serde(borrow)]

     

       177
       177
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       178
       178
       +
           /// The number of unique listeners who have played the artist.

     

       179
       179
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       180
       180
       +
           pub unique_listeners: std::option::Option<i64>,

     

       181
       181
       +
           /// The URI of the artist.

     

       182
       182
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       183
       183
       +
           #[serde(borrow)]

     

       184
       184
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       185
       185
       +
       }

+76

crates/jacquard-api/src/app_rocksky/charts/get_scrobbles_chart.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.charts.getScrobblesChart

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetScrobblesChart<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub albumuri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           #[serde(borrow)]

     

       26
       26
       +
           pub artisturi: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           #[serde(borrow)]

     

       29
       29
       +
           pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[serde(borrow)]

     

       32
       32
       +
           pub songuri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       #[jacquard_derive::lexicon]

     

       36
       36
       +
       #[derive(

     

       37
       37
       +
           serde::Serialize,

     

       38
       38
       +
           serde::Deserialize,

     

       39
       39
       +
           Debug,

     

       40
       40
       +
           Clone,

     

       41
       41
       +
           PartialEq,

     

       42
       42
       +
           Eq,

     

       43
       43
       +
           jacquard_derive::IntoStatic

     

       44
       44
       +
       )]

     

       45
       45
       +
       #[serde(rename_all = "camelCase")]

     

       46
       46
       +
       pub struct GetScrobblesChartOutput<'a> {

     

       47
       47
       +
           #[serde(flatten)]

     

       48
       48
       +
           #[serde(borrow)]

     

       49
       49
       +
           pub value: crate::app_rocksky::charts::ChartsView<'a>,

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       ///Response type for

     

       53
       53
       +
       ///app.rocksky.charts.getScrobblesChart

     

       54
       54
       +
       pub struct GetScrobblesChartResponse;

     

       55
       55
       +
       impl jacquard_common::xrpc::XrpcResp for GetScrobblesChartResponse {

     

       56
       56
       +
           const NSID: &'static str = "app.rocksky.charts.getScrobblesChart";

     

       57
       57
       +
           const ENCODING: &'static str = "application/json";

     

       58
       58
       +
           type Output<'de> = GetScrobblesChartOutput<'de>;

     

       59
       59
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobblesChart<'a> {

     

       63
       63
       +
           const NSID: &'static str = "app.rocksky.charts.getScrobblesChart";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Response = GetScrobblesChartResponse;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       ///Endpoint type for

     

       69
       69
       +
       ///app.rocksky.charts.getScrobblesChart

     

       70
       70
       +
       pub struct GetScrobblesChartRequest;

     

       71
       71
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetScrobblesChartRequest {

     

       72
       72
       +
           const PATH: &'static str = "/xrpc/app.rocksky.charts.getScrobblesChart";

     

       73
       73
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       74
       74
       +
           type Request<'de> = GetScrobblesChart<'de>;

     

       75
       75
       +
           type Response = GetScrobblesChartResponse;

     

       76
       76
       +
       }

+49

crates/jacquard-api/src/app_rocksky/charts.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.charts.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_scrobbles_chart;

     

       9
       9
       +
       

     

       10
       10
       +
       #[jacquard_derive::lexicon]

     

       11
       11
       +
       #[derive(

     

       12
       12
       +
           serde::Serialize,

     

       13
       13
       +
           serde::Deserialize,

     

       14
       14
       +
           Debug,

     

       15
       15
       +
           Clone,

     

       16
       16
       +
           PartialEq,

     

       17
       17
       +
           Eq,

     

       18
       18
       +
           jacquard_derive::IntoStatic,

     

       19
       19
       +
           Default

     

       20
       20
       +
       )]

     

       21
       21
       +
       #[serde(rename_all = "camelCase")]

     

       22
       22
       +
       pub struct ChartsView<'a> {

     

       23
       23
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
       +
           #[serde(borrow)]

     

       25
       25
       +
           pub scrobbles: std::option::Option<

     

       26
       26
       +
               Vec<crate::app_rocksky::charts::ScrobbleViewBasic<'a>>,

     

       27
       27
       +
           >,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       #[jacquard_derive::lexicon]

     

       31
       31
       +
       #[derive(

     

       32
       32
       +
           serde::Serialize,

     

       33
       33
       +
           serde::Deserialize,

     

       34
       34
       +
           Debug,

     

       35
       35
       +
           Clone,

     

       36
       36
       +
           PartialEq,

     

       37
       37
       +
           Eq,

     

       38
       38
       +
           jacquard_derive::IntoStatic,

     

       39
       39
       +
           Default

     

       40
       40
       +
       )]

     

       41
       41
       +
       #[serde(rename_all = "camelCase")]

     

       42
       42
       +
       pub struct ScrobbleViewBasic<'a> {

     

       43
       43
       +
           /// The number of scrobbles on this date.

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           pub count: std::option::Option<i64>,

     

       46
       46
       +
           /// The date of the scrobble.

     

       47
       47
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
       +
           pub date: std::option::Option<jacquard_common::types::string::Datetime>,

     

       49
       49
       +
       }

+62

crates/jacquard-api/src/app_rocksky/dropbox/download_file.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.dropbox.downloadFile

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct DownloadFile<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub file_id: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct DownloadFileOutput<'a> {}

     

       38
       38
       +
       ///Response type for

     

       39
       39
       +
       ///app.rocksky.dropbox.downloadFile

     

       40
       40
       +
       pub struct DownloadFileResponse;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcResp for DownloadFileResponse {

     

       42
       42
       +
           const NSID: &'static str = "app.rocksky.dropbox.downloadFile";

     

       43
       43
       +
           const ENCODING: &'static str = "application/octet-stream";

     

       44
       44
       +
           type Output<'de> = DownloadFileOutput<'de>;

     

       45
       45
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for DownloadFile<'a> {

     

       49
       49
       +
           const NSID: &'static str = "app.rocksky.dropbox.downloadFile";

     

       50
       50
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       51
       51
       +
           type Response = DownloadFileResponse;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       ///Endpoint type for

     

       55
       55
       +
       ///app.rocksky.dropbox.downloadFile

     

       56
       56
       +
       pub struct DownloadFileRequest;

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcEndpoint for DownloadFileRequest {

     

       58
       58
       +
           const PATH: &'static str = "/xrpc/app.rocksky.dropbox.downloadFile";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       60
       60
       +
           type Request<'de> = DownloadFile<'de>;

     

       61
       61
       +
           type Response = DownloadFileResponse;

     

       62
       62
       +
       }

+68

crates/jacquard-api/src/app_rocksky/dropbox/get_files.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.dropbox.getFiles

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetFiles<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           #[builder(into)]

     

       24
       24
       +
           pub at: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct GetFilesOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::dropbox::FileListView<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.dropbox.getFiles

     

       46
       46
       +
       pub struct GetFilesResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for GetFilesResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.dropbox.getFiles";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = GetFilesOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetFiles<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.dropbox.getFiles";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       57
       57
       +
           type Response = GetFilesResponse;

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       ///Endpoint type for

     

       61
       61
       +
       ///app.rocksky.dropbox.getFiles

     

       62
       62
       +
       pub struct GetFilesRequest;

     

       63
       63
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetFilesRequest {

     

       64
       64
       +
           const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getFiles";

     

       65
       65
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       66
       66
       +
           type Request<'de> = GetFiles<'de>;

     

       67
       67
       +
           type Response = GetFilesResponse;

     

       68
       68
       +
       }

+67

crates/jacquard-api/src/app_rocksky/dropbox/get_metadata.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.dropbox.getMetadata

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetMetadata<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub path: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetMetadataOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::dropbox::FileView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.dropbox.getMetadata

     

       45
       45
       +
       pub struct GetMetadataResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetMetadataResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.dropbox.getMetadata";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetMetadataOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetMetadata<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.dropbox.getMetadata";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetMetadataResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.dropbox.getMetadata

     

       61
       61
       +
       pub struct GetMetadataRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetMetadataRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getMetadata";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetMetadata<'de>;

     

       66
       66
       +
           type Response = GetMetadataResponse;

     

       67
       67
       +
       }

+67

crates/jacquard-api/src/app_rocksky/dropbox/get_temporary_link.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.dropbox.getTemporaryLink

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetTemporaryLink<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub path: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetTemporaryLinkOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::dropbox::TemporaryLinkView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.dropbox.getTemporaryLink

     

       45
       45
       +
       pub struct GetTemporaryLinkResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetTemporaryLinkResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.dropbox.getTemporaryLink";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetTemporaryLinkOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetTemporaryLink<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.dropbox.getTemporaryLink";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetTemporaryLinkResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.dropbox.getTemporaryLink

     

       61
       61
       +
       pub struct GetTemporaryLinkRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetTemporaryLinkRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.dropbox.getTemporaryLink";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetTemporaryLink<'de>;

     

       66
       66
       +
           type Response = GetTemporaryLinkResponse;

     

       67
       67
       +
       }

+86

crates/jacquard-api/src/app_rocksky/dropbox.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.dropbox.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod download_file;

     

       9
       9
       +
       pub mod get_files;

     

       10
       10
       +
       pub mod get_metadata;

     

       11
       11
       +
       pub mod get_temporary_link;

     

       12
       12
       +
       

     

       13
       13
       +
       #[jacquard_derive::lexicon]

     

       14
       14
       +
       #[derive(

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           Debug,

     

       18
       18
       +
           Clone,

     

       19
       19
       +
           PartialEq,

     

       20
       20
       +
           Eq,

     

       21
       21
       +
           jacquard_derive::IntoStatic,

     

       22
       22
       +
           Default

     

       23
       23
       +
       )]

     

       24
       24
       +
       #[serde(rename_all = "camelCase")]

     

       25
       25
       +
       pub struct FileListView<'a> {

     

       26
       26
       +
           /// A list of files in the Dropbox.

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           #[serde(borrow)]

     

       29
       29
       +
           pub files: std::option::Option<Vec<crate::app_rocksky::dropbox::FileView<'a>>>,

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       #[jacquard_derive::lexicon]

     

       33
       33
       +
       #[derive(

     

       34
       34
       +
           serde::Serialize,

     

       35
       35
       +
           serde::Deserialize,

     

       36
       36
       +
           Debug,

     

       37
       37
       +
           Clone,

     

       38
       38
       +
           PartialEq,

     

       39
       39
       +
           Eq,

     

       40
       40
       +
           jacquard_derive::IntoStatic,

     

       41
       41
       +
           Default

     

       42
       42
       +
       )]

     

       43
       43
       +
       #[serde(rename_all = "camelCase")]

     

       44
       44
       +
       pub struct FileView<'a> {

     

       45
       45
       +
           /// The last modified date and time of the file on the client.

     

       46
       46
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       47
       47
       +
           pub client_modified: std::option::Option<jacquard_common::types::string::Datetime>,

     

       48
       48
       +
           /// The unique identifier of the file.

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[serde(borrow)]

     

       51
       51
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       52
       52
       +
           /// The name of the file.

     

       53
       53
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       56
       56
       +
           /// The display path of the file.

     

       57
       57
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
       +
           #[serde(borrow)]

     

       59
       59
       +
           pub path_display: std::option::Option<jacquard_common::CowStr<'a>>,

     

       60
       60
       +
           /// The lowercased path of the file.

     

       61
       61
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
       +
           #[serde(borrow)]

     

       63
       63
       +
           pub path_lower: std::option::Option<jacquard_common::CowStr<'a>>,

     

       64
       64
       +
           /// The last modified date and time of the file on the server.

     

       65
       65
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       66
       66
       +
           pub server_modified: std::option::Option<jacquard_common::types::string::Datetime>,

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       #[jacquard_derive::lexicon]

     

       70
       70
       +
       #[derive(

     

       71
       71
       +
           serde::Serialize,

     

       72
       72
       +
           serde::Deserialize,

     

       73
       73
       +
           Debug,

     

       74
       74
       +
           Clone,

     

       75
       75
       +
           PartialEq,

     

       76
       76
       +
           Eq,

     

       77
       77
       +
           jacquard_derive::IntoStatic,

     

       78
       78
       +
           Default

     

       79
       79
       +
       )]

     

       80
       80
       +
       #[serde(rename_all = "camelCase")]

     

       81
       81
       +
       pub struct TemporaryLinkView<'a> {

     

       82
       82
       +
           /// The temporary link to access the file.

     

       83
       83
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       84
       84
       +
           #[serde(borrow)]

     

       85
       85
       +
           pub link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       86
       86
       +
       }

+67

crates/jacquard-api/src/app_rocksky/feed/get_now_playings.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.feed.getNowPlayings

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetNowPlayings {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub size: std::option::Option<i64>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetNowPlayingsOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::feed::NowPlayingsView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.feed.getNowPlayings

     

       45
       45
       +
       pub struct GetNowPlayingsResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetNowPlayingsResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.feed.getNowPlayings";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetNowPlayingsOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl jacquard_common::xrpc::XrpcRequest for GetNowPlayings {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.feed.getNowPlayings";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetNowPlayingsResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.feed.getNowPlayings

     

       61
       61
       +
       pub struct GetNowPlayingsRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetNowPlayingsRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.feed.getNowPlayings";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetNowPlayings;

     

       66
       66
       +
           type Response = GetNowPlayingsResponse;

     

       67
       67
       +
       }

+67

crates/jacquard-api/src/app_rocksky/feed/search.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.feed.search

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct Search<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub query: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct SearchOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::feed::SearchResultsView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.feed.search

     

       45
       45
       +
       pub struct SearchResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for SearchResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.feed.search";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = SearchOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for Search<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.feed.search";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = SearchResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.feed.search

     

       61
       61
       +
       pub struct SearchRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for SearchRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.feed.search";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = Search<'de>;

     

       66
       66
       +
           type Response = SearchResponse;

     

       67
       67
       +
       }

+140

crates/jacquard-api/src/app_rocksky/feed.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.feed.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_now_playings;

     

       9
       9
       +
       pub mod search;

     

       10
       10
       +
       

     

       11
       11
       +
       #[jacquard_derive::lexicon]

     

       12
       12
       +
       #[derive(

     

       13
       13
       +
           serde::Serialize,

     

       14
       14
       +
           serde::Deserialize,

     

       15
       15
       +
           Debug,

     

       16
       16
       +
           Clone,

     

       17
       17
       +
           PartialEq,

     

       18
       18
       +
           Eq,

     

       19
       19
       +
           jacquard_derive::IntoStatic,

     

       20
       20
       +
           Default

     

       21
       21
       +
       )]

     

       22
       22
       +
       #[serde(rename_all = "camelCase")]

     

       23
       23
       +
       pub struct NowPlayingView<'a> {

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           #[serde(borrow)]

     

       26
       26
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           #[serde(borrow)]

     

       29
       29
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[serde(borrow)]

     

       32
       32
       +
           pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           #[serde(borrow)]

     

       35
       35
       +
           pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       36
       36
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       37
       37
       +
           #[serde(borrow)]

     

       38
       38
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       39
       39
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       42
       42
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub created_at: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       49
       49
       +
           #[serde(borrow)]

     

       50
       50
       +
           pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       51
       51
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       52
       52
       +
           #[serde(borrow)]

     

       53
       53
       +
           pub handle: std::option::Option<jacquard_common::CowStr<'a>>,

     

       54
       54
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       55
       55
       +
           #[serde(borrow)]

     

       56
       56
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       57
       57
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
       +
           #[serde(borrow)]

     

       59
       59
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       60
       60
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       61
       61
       +
           #[serde(borrow)]

     

       62
       62
       +
           pub track_id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       63
       63
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       64
       64
       +
           #[serde(borrow)]

     

       65
       65
       +
           pub track_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       66
       66
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       67
       67
       +
           #[serde(borrow)]

     

       68
       68
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       #[jacquard_derive::lexicon]

     

       72
       72
       +
       #[derive(

     

       73
       73
       +
           serde::Serialize,

     

       74
       74
       +
           serde::Deserialize,

     

       75
       75
       +
           Debug,

     

       76
       76
       +
           Clone,

     

       77
       77
       +
           PartialEq,

     

       78
       78
       +
           Eq,

     

       79
       79
       +
           jacquard_derive::IntoStatic,

     

       80
       80
       +
           Default

     

       81
       81
       +
       )]

     

       82
       82
       +
       #[serde(rename_all = "camelCase")]

     

       83
       83
       +
       pub struct NowPlayingsView<'a> {

     

       84
       84
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       85
       85
       +
           #[serde(borrow)]

     

       86
       86
       +
           pub now_playings: std::option::Option<

     

       87
       87
       +
               Vec<crate::app_rocksky::feed::NowPlayingView<'a>>,

     

       88
       88
       +
           >,

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       #[jacquard_derive::lexicon]

     

       92
       92
       +
       #[derive(

     

       93
       93
       +
           serde::Serialize,

     

       94
       94
       +
           serde::Deserialize,

     

       95
       95
       +
           Debug,

     

       96
       96
       +
           Clone,

     

       97
       97
       +
           PartialEq,

     

       98
       98
       +
           Eq,

     

       99
       99
       +
           jacquard_derive::IntoStatic,

     

       100
       100
       +
           Default

     

       101
       101
       +
       )]

     

       102
       102
       +
       #[serde(rename_all = "camelCase")]

     

       103
       103
       +
       pub struct SearchResultsView<'a> {

     

       104
       104
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       105
       105
       +
           pub estimated_total_hits: std::option::Option<i64>,

     

       106
       106
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       107
       107
       +
           #[serde(borrow)]

     

       108
       108
       +
           pub hits: std::option::Option<Vec<SearchResultsViewHitsItem<'a>>>,

     

       109
       109
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       110
       110
       +
           pub limit: std::option::Option<i64>,

     

       111
       111
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       112
       112
       +
           pub offset: std::option::Option<i64>,

     

       113
       113
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       114
       114
       +
           pub processing_time_ms: std::option::Option<i64>,

     

       115
       115
       +
       }

     

       116
       116
       +
       

     

       117
       117
       +
       #[jacquard_derive::open_union]

     

       118
       118
       +
       #[derive(

     

       119
       119
       +
           serde::Serialize,

     

       120
       120
       +
           serde::Deserialize,

     

       121
       121
       +
           Debug,

     

       122
       122
       +
           Clone,

     

       123
       123
       +
           PartialEq,

     

       124
       124
       +
           Eq,

     

       125
       125
       +
           jacquard_derive::IntoStatic

     

       126
       126
       +
       )]

     

       127
       127
       +
       #[serde(tag = "$type")]

     

       128
       128
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       129
       129
       +
       pub enum SearchResultsViewHitsItem<'a> {

     

       130
       130
       +
           #[serde(rename = "app.rocksky.song.defs#songViewBasic")]

     

       131
       131
       +
           SongViewBasic(Box<crate::app_rocksky::song::SongViewBasic<'a>>),

     

       132
       132
       +
           #[serde(rename = "app.rocksky.album.defs#albumViewBasic")]

     

       133
       133
       +
           AlbumViewBasic(Box<crate::app_rocksky::album::AlbumViewBasic<'a>>),

     

       134
       134
       +
           #[serde(rename = "app.rocksky.artist.defs#artistViewBasic")]

     

       135
       135
       +
           ArtistViewBasic(Box<crate::app_rocksky::artist::ArtistViewBasic<'a>>),

     

       136
       136
       +
           #[serde(rename = "app.rocksky.playlist.defs#playlistViewBasic")]

     

       137
       137
       +
           PlaylistViewBasic(Box<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>),

     

       138
       138
       +
           #[serde(rename = "app.rocksky.actor.defs#profileViewBasic")]

     

       139
       139
       +
           ProfileViewBasic(Box<crate::app_rocksky::actor::ProfileViewBasic<'a>>),

     

       140
       140
       +
       }

+62

crates/jacquard-api/src/app_rocksky/googledrive/download_file.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.googledrive.downloadFile

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct DownloadFile<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub file_id: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct DownloadFileOutput<'a> {}

     

       38
       38
       +
       ///Response type for

     

       39
       39
       +
       ///app.rocksky.googledrive.downloadFile

     

       40
       40
       +
       pub struct DownloadFileResponse;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcResp for DownloadFileResponse {

     

       42
       42
       +
           const NSID: &'static str = "app.rocksky.googledrive.downloadFile";

     

       43
       43
       +
           const ENCODING: &'static str = "application/octet-stream";

     

       44
       44
       +
           type Output<'de> = DownloadFileOutput<'de>;

     

       45
       45
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for DownloadFile<'a> {

     

       49
       49
       +
           const NSID: &'static str = "app.rocksky.googledrive.downloadFile";

     

       50
       50
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       51
       51
       +
           type Response = DownloadFileResponse;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       ///Endpoint type for

     

       55
       55
       +
       ///app.rocksky.googledrive.downloadFile

     

       56
       56
       +
       pub struct DownloadFileRequest;

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcEndpoint for DownloadFileRequest {

     

       58
       58
       +
           const PATH: &'static str = "/xrpc/app.rocksky.googledrive.downloadFile";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       60
       60
       +
           type Request<'de> = DownloadFile<'de>;

     

       61
       61
       +
           type Response = DownloadFileResponse;

     

       62
       62
       +
       }

+67

crates/jacquard-api/src/app_rocksky/googledrive/get_file.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.googledrive.getFile

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetFile<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub file_id: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetFileOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::googledrive::FileView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.googledrive.getFile

     

       45
       45
       +
       pub struct GetFileResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetFileResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.googledrive.getFile";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetFileOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetFile<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.googledrive.getFile";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetFileResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.googledrive.getFile

     

       61
       61
       +
       pub struct GetFileRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetFileRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.googledrive.getFile";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetFile<'de>;

     

       66
       66
       +
           type Response = GetFileResponse;

     

       67
       67
       +
       }

+68

crates/jacquard-api/src/app_rocksky/googledrive/get_files.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.googledrive.getFiles

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetFiles<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           #[builder(into)]

     

       24
       24
       +
           pub at: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct GetFilesOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::googledrive::FileListView<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.googledrive.getFiles

     

       46
       46
       +
       pub struct GetFilesResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for GetFilesResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.googledrive.getFiles";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = GetFilesOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetFiles<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.googledrive.getFiles";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       57
       57
       +
           type Response = GetFilesResponse;

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       ///Endpoint type for

     

       61
       61
       +
       ///app.rocksky.googledrive.getFiles

     

       62
       62
       +
       pub struct GetFilesRequest;

     

       63
       63
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetFilesRequest {

     

       64
       64
       +
           const PATH: &'static str = "/xrpc/app.rocksky.googledrive.getFiles";

     

       65
       65
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       66
       66
       +
           type Request<'de> = GetFiles<'de>;

     

       67
       67
       +
           type Response = GetFilesResponse;

     

       68
       68
       +
       }

+47

crates/jacquard-api/src/app_rocksky/googledrive.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.googledrive.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod download_file;

     

       9
       9
       +
       pub mod get_file;

     

       10
       10
       +
       pub mod get_files;

     

       11
       11
       +
       

     

       12
       12
       +
       #[jacquard_derive::lexicon]

     

       13
       13
       +
       #[derive(

     

       14
       14
       +
           serde::Serialize,

     

       15
       15
       +
           serde::Deserialize,

     

       16
       16
       +
           Debug,

     

       17
       17
       +
           Clone,

     

       18
       18
       +
           PartialEq,

     

       19
       19
       +
           Eq,

     

       20
       20
       +
           jacquard_derive::IntoStatic,

     

       21
       21
       +
           Default

     

       22
       22
       +
       )]

     

       23
       23
       +
       #[serde(rename_all = "camelCase")]

     

       24
       24
       +
       pub struct FileListView<'a> {

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub files: std::option::Option<Vec<crate::app_rocksky::googledrive::FileView<'a>>>,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       #[jacquard_derive::lexicon]

     

       31
       31
       +
       #[derive(

     

       32
       32
       +
           serde::Serialize,

     

       33
       33
       +
           serde::Deserialize,

     

       34
       34
       +
           Debug,

     

       35
       35
       +
           Clone,

     

       36
       36
       +
           PartialEq,

     

       37
       37
       +
           Eq,

     

       38
       38
       +
           jacquard_derive::IntoStatic,

     

       39
       39
       +
           Default

     

       40
       40
       +
       )]

     

       41
       41
       +
       #[serde(rename_all = "camelCase")]

     

       42
       42
       +
       pub struct FileView<'a> {

     

       43
       43
       +
           /// The unique identifier of the file.

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       47
       47
       +
       }

+72

crates/jacquard-api/src/app_rocksky/like/dislike_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.like.dislikeShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct DislikeShout<'a> {

     

       21
       21
       +
           /// The unique identifier of the shout to dislike

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct DislikeShoutOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.like.dislikeShout

     

       46
       46
       +
       pub struct DislikeShoutResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for DislikeShoutResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.like.dislikeShout";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = DislikeShoutOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for DislikeShout<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.like.dislikeShout";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       57
       57
       +
               "application/json",

     

       58
       58
       +
           );

     

       59
       59
       +
           type Response = DislikeShoutResponse;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       ///Endpoint type for

     

       63
       63
       +
       ///app.rocksky.like.dislikeShout

     

       64
       64
       +
       pub struct DislikeShoutRequest;

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcEndpoint for DislikeShoutRequest {

     

       66
       66
       +
           const PATH: &'static str = "/xrpc/app.rocksky.like.dislikeShout";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Request<'de> = DislikeShout<'de>;

     

       71
       71
       +
           type Response = DislikeShoutResponse;

     

       72
       72
       +
       }

+72

crates/jacquard-api/src/app_rocksky/like/dislike_song.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.like.dislikeSong

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct DislikeSong<'a> {

     

       21
       21
       +
           /// The unique identifier of the song to dislike

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct DislikeSongOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::song::SongViewDetailed<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.like.dislikeSong

     

       46
       46
       +
       pub struct DislikeSongResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for DislikeSongResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.like.dislikeSong";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = DislikeSongOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for DislikeSong<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.like.dislikeSong";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       57
       57
       +
               "application/json",

     

       58
       58
       +
           );

     

       59
       59
       +
           type Response = DislikeSongResponse;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       ///Endpoint type for

     

       63
       63
       +
       ///app.rocksky.like.dislikeSong

     

       64
       64
       +
       pub struct DislikeSongRequest;

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcEndpoint for DislikeSongRequest {

     

       66
       66
       +
           const PATH: &'static str = "/xrpc/app.rocksky.like.dislikeSong";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Request<'de> = DislikeSong<'de>;

     

       71
       71
       +
           type Response = DislikeSongResponse;

     

       72
       72
       +
       }

+72

crates/jacquard-api/src/app_rocksky/like/like_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.like.likeShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct LikeShout<'a> {

     

       21
       21
       +
           /// The unique identifier of the shout to like

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct LikeShoutOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.like.likeShout

     

       46
       46
       +
       pub struct LikeShoutResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for LikeShoutResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.like.likeShout";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = LikeShoutOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for LikeShout<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.like.likeShout";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       57
       57
       +
               "application/json",

     

       58
       58
       +
           );

     

       59
       59
       +
           type Response = LikeShoutResponse;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       ///Endpoint type for

     

       63
       63
       +
       ///app.rocksky.like.likeShout

     

       64
       64
       +
       pub struct LikeShoutRequest;

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcEndpoint for LikeShoutRequest {

     

       66
       66
       +
           const PATH: &'static str = "/xrpc/app.rocksky.like.likeShout";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Request<'de> = LikeShout<'de>;

     

       71
       71
       +
           type Response = LikeShoutResponse;

     

       72
       72
       +
       }

+72

crates/jacquard-api/src/app_rocksky/like/like_song.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.like.likeSong

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct LikeSong<'a> {

     

       21
       21
       +
           /// The unique identifier of the song to like

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct LikeSongOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::song::SongViewDetailed<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.like.likeSong

     

       46
       46
       +
       pub struct LikeSongResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for LikeSongResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.like.likeSong";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = LikeSongOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for LikeSong<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.like.likeSong";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       57
       57
       +
               "application/json",

     

       58
       58
       +
           );

     

       59
       59
       +
           type Response = LikeSongResponse;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       ///Endpoint type for

     

       63
       63
       +
       ///app.rocksky.like.likeSong

     

       64
       64
       +
       pub struct LikeSongRequest;

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcEndpoint for LikeSongRequest {

     

       66
       66
       +
           const PATH: &'static str = "/xrpc/app.rocksky.like.likeSong";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Request<'de> = LikeSong<'de>;

     

       71
       71
       +
           type Response = LikeSongResponse;

     

       72
       72
       +
       }

+73

crates/jacquard-api/src/app_rocksky/like.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.like

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod dislike_shout;

     

       9
       9
       +
       pub mod dislike_song;

     

       10
       10
       +
       pub mod like_shout;

     

       11
       11
       +
       pub mod like_song;

     

       12
       12
       +
       

     

       13
       13
       +
       /// A declaration of a like.

     

       14
       14
       +
       #[jacquard_derive::lexicon]

     

       15
       15
       +
       #[derive(

     

       16
       16
       +
           serde::Serialize,

     

       17
       17
       +
           serde::Deserialize,

     

       18
       18
       +
           Debug,

     

       19
       19
       +
           Clone,

     

       20
       20
       +
           PartialEq,

     

       21
       21
       +
           Eq,

     

       22
       22
       +
           jacquard_derive::IntoStatic,

     

       23
       23
       +
           bon::Builder

     

       24
       24
       +
       )]

     

       25
       25
       +
       #[serde(rename_all = "camelCase")]

     

       26
       26
       +
       pub struct Like<'a> {

     

       27
       27
       +
           /// The date when the like was created.

     

       28
       28
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       29
       29
       +
           #[serde(borrow)]

     

       30
       30
       +
           pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       34
       34
       +
       #[derive(

     

       35
       35
       +
           serde::Serialize,

     

       36
       36
       +
           serde::Deserialize,

     

       37
       37
       +
           Debug,

     

       38
       38
       +
           Clone,

     

       39
       39
       +
           PartialEq,

     

       40
       40
       +
           Eq,

     

       41
       41
       +
           jacquard_derive::IntoStatic

     

       42
       42
       +
       )]

     

       43
       43
       +
       #[serde(rename_all = "camelCase")]

     

       44
       44
       +
       pub struct LikeGetRecordOutput<'a> {

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       48
       48
       +
           #[serde(borrow)]

     

       49
       49
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       50
       50
       +
           #[serde(borrow)]

     

       51
       51
       +
           pub value: Like<'a>,

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       /// Marker type for deserializing records from this collection.

     

       55
       55
       +
       pub struct LikeRecord;

     

       56
       56
       +
       impl jacquard_common::xrpc::XrpcResp for LikeRecord {

     

       57
       57
       +
           const NSID: &'static str = "app.rocksky.like";

     

       58
       58
       +
           const ENCODING: &'static str = "application/json";

     

       59
       59
       +
           type Output<'de> = LikeGetRecordOutput<'de>;

     

       60
       60
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       impl jacquard_common::types::collection::Collection for Like<'_> {

     

       64
       64
       +
           const NSID: &'static str = "app.rocksky.like";

     

       65
       65
       +
           type Record = LikeRecord;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       impl From<LikeGetRecordOutput<'_>> for Like<'_> {

     

       69
       69
       +
           fn from(output: LikeGetRecordOutput<'_>) -> Self {

     

       70
       70
       +
               use jacquard_common::IntoStatic;

     

       71
       71
       +
               output.value.into_static()

     

       72
       72
       +
           }

     

       73
       73
       +
       }

+67

crates/jacquard-api/src/app_rocksky/player/get_currently_playing.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.getCurrentlyPlaying

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetCurrentlyPlaying<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub actor: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetCurrentlyPlayingOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::player::CurrentlyPlayingViewDetailed<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.player.getCurrentlyPlaying

     

       45
       45
       +
       pub struct GetCurrentlyPlayingResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetCurrentlyPlayingResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.player.getCurrentlyPlaying";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetCurrentlyPlayingOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetCurrentlyPlaying<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.player.getCurrentlyPlaying";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetCurrentlyPlayingResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.player.getCurrentlyPlaying

     

       61
       61
       +
       pub struct GetCurrentlyPlayingRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetCurrentlyPlayingRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.getCurrentlyPlaying";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetCurrentlyPlaying<'de>;

     

       66
       66
       +
           type Response = GetCurrentlyPlayingResponse;

     

       67
       67
       +
       }

+48

crates/jacquard-api/src/app_rocksky/player/next.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.next

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Next;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.player.next

     

       22
       22
       +
       pub struct NextResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for NextResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.player.next";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Next {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.player.next";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = NextResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.player.next

     

       40
       40
       +
       pub struct NextRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for NextRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.next";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Next;

     

       47
       47
       +
           type Response = NextResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/player/pause.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.pause

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Pause;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.player.pause

     

       22
       22
       +
       pub struct PauseResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PauseResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.player.pause";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Pause {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.player.pause";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PauseResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.player.pause

     

       40
       40
       +
       pub struct PauseRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PauseRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.pause";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Pause;

     

       47
       47
       +
           type Response = PauseResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/player/play.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.play

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Play;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.player.play

     

       22
       22
       +
       pub struct PlayResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PlayResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.player.play";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Play {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.player.play";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PlayResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.player.play

     

       40
       40
       +
       pub struct PlayRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PlayRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.play";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Play;

     

       47
       47
       +
           type Response = PlayResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/player/previous.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.previous

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Previous;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.player.previous

     

       22
       22
       +
       pub struct PreviousResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PreviousResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.player.previous";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Previous {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.player.previous";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PreviousResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.player.previous

     

       40
       40
       +
       pub struct PreviousRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PreviousRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.previous";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Previous;

     

       47
       47
       +
           type Response = PreviousResponse;

     

       48
       48
       +
       }

+64

crates/jacquard-api/src/app_rocksky/player/seek.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.seek

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct SeekParams {

     

       21
       21
       +
           pub position: i64,

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       /// XRPC request marker type

     

       25
       25
       +
       #[derive(

     

       26
       26
       +
           Debug,

     

       27
       27
       +
           Clone,

     

       28
       28
       +
           Copy,

     

       29
       29
       +
           PartialEq,

     

       30
       30
       +
           Eq,

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       pub struct Seek;

     

       36
       36
       +
       ///Response type for

     

       37
       37
       +
       ///app.rocksky.player.seek

     

       38
       38
       +
       pub struct SeekResponse;

     

       39
       39
       +
       impl jacquard_common::xrpc::XrpcResp for SeekResponse {

     

       40
       40
       +
           const NSID: &'static str = "app.rocksky.player.seek";

     

       41
       41
       +
           const ENCODING: &'static str = "application/json";

     

       42
       42
       +
           type Output<'de> = ();

     

       43
       43
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcRequest for Seek {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.player.seek";

     

       48
       48
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       49
       49
       +
               "application/json",

     

       50
       50
       +
           );

     

       51
       51
       +
           type Response = SeekResponse;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       ///Endpoint type for

     

       55
       55
       +
       ///app.rocksky.player.seek

     

       56
       56
       +
       pub struct SeekRequest;

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcEndpoint for SeekRequest {

     

       58
       58
       +
           const PATH: &'static str = "/xrpc/app.rocksky.player.seek";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       60
       60
       +
               "application/json",

     

       61
       61
       +
           );

     

       62
       62
       +
           type Request<'de> = Seek;

     

       63
       63
       +
           type Response = SeekResponse;

     

       64
       64
       +
       }

+32

crates/jacquard-api/src/app_rocksky/player.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.player.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_currently_playing;

     

       9
       9
       +
       pub mod next;

     

       10
       10
       +
       pub mod pause;

     

       11
       11
       +
       pub mod play;

     

       12
       12
       +
       pub mod previous;

     

       13
       13
       +
       pub mod seek;

     

       14
       14
       +
       

     

       15
       15
       +
       #[jacquard_derive::lexicon]

     

       16
       16
       +
       #[derive(

     

       17
       17
       +
           serde::Serialize,

     

       18
       18
       +
           serde::Deserialize,

     

       19
       19
       +
           Debug,

     

       20
       20
       +
           Clone,

     

       21
       21
       +
           PartialEq,

     

       22
       22
       +
           Eq,

     

       23
       23
       +
           jacquard_derive::IntoStatic,

     

       24
       24
       +
           Default

     

       25
       25
       +
       )]

     

       26
       26
       +
       #[serde(rename_all = "camelCase")]

     

       27
       27
       +
       pub struct CurrentlyPlayingViewDetailed<'a> {

     

       28
       28
       +
           /// The title of the currently playing track

     

       29
       29
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       30
       30
       +
           #[serde(borrow)]

     

       31
       31
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       32
       32
       +
       }

+66

crates/jacquard-api/src/app_rocksky/playlist/get_playlist.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.playlist.getPlaylist

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetPlaylist<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetPlaylistOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::playlist::PlaylistViewDetailed<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.playlist.getPlaylist

     

       44
       44
       +
       pub struct GetPlaylistResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetPlaylistResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.playlist.getPlaylist";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetPlaylistOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetPlaylist<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.playlist.getPlaylist";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetPlaylistResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.playlist.getPlaylist

     

       60
       60
       +
       pub struct GetPlaylistRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetPlaylistRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.playlist.getPlaylist";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetPlaylist<'de>;

     

       65
       65
       +
           type Response = GetPlaylistResponse;

     

       66
       66
       +
       }

+71

crates/jacquard-api/src/app_rocksky/playlist/get_playlists.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.playlist.getPlaylists

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetPlaylists {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           pub limit: std::option::Option<i64>,

     

       23
       23
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       24
       24
       +
           pub offset: std::option::Option<i64>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic,

     

       36
       36
       +
           Default

     

       37
       37
       +
       )]

     

       38
       38
       +
       #[serde(rename_all = "camelCase")]

     

       39
       39
       +
       pub struct GetPlaylistsOutput<'a> {

     

       40
       40
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
       +
           #[serde(borrow)]

     

       42
       42
       +
           pub playlists: std::option::Option<

     

       43
       43
       +
               Vec<crate::app_rocksky::playlist::PlaylistViewBasic<'a>>,

     

       44
       44
       +
           >,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       ///Response type for

     

       48
       48
       +
       ///app.rocksky.playlist.getPlaylists

     

       49
       49
       +
       pub struct GetPlaylistsResponse;

     

       50
       50
       +
       impl jacquard_common::xrpc::XrpcResp for GetPlaylistsResponse {

     

       51
       51
       +
           const NSID: &'static str = "app.rocksky.playlist.getPlaylists";

     

       52
       52
       +
           const ENCODING: &'static str = "application/json";

     

       53
       53
       +
           type Output<'de> = GetPlaylistsOutput<'de>;

     

       54
       54
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcRequest for GetPlaylists {

     

       58
       58
       +
           const NSID: &'static str = "app.rocksky.playlist.getPlaylists";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       60
       60
       +
           type Response = GetPlaylistsResponse;

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       ///Endpoint type for

     

       64
       64
       +
       ///app.rocksky.playlist.getPlaylists

     

       65
       65
       +
       pub struct GetPlaylistsRequest;

     

       66
       66
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetPlaylistsRequest {

     

       67
       67
       +
           const PATH: &'static str = "/xrpc/app.rocksky.playlist.getPlaylists";

     

       68
       68
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       69
       69
       +
           type Request<'de> = GetPlaylists;

     

       70
       70
       +
           type Response = GetPlaylistsResponse;

     

       71
       71
       +
       }

+233

crates/jacquard-api/src/app_rocksky/playlist.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.playlist.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_playlist;

     

       9
       9
       +
       pub mod get_playlists;

     

       10
       10
       +
       

     

       11
       11
       +
       /// A declaration of a playlist.

     

       12
       12
       +
       #[jacquard_derive::lexicon]

     

       13
       13
       +
       #[derive(

     

       14
       14
       +
           serde::Serialize,

     

       15
       15
       +
           serde::Deserialize,

     

       16
       16
       +
           Debug,

     

       17
       17
       +
           Clone,

     

       18
       18
       +
           PartialEq,

     

       19
       19
       +
           Eq,

     

       20
       20
       +
           jacquard_derive::IntoStatic,

     

       21
       21
       +
           bon::Builder

     

       22
       22
       +
       )]

     

       23
       23
       +
       #[serde(rename_all = "camelCase")]

     

       24
       24
       +
       pub struct Playlist<'a> {

     

       25
       25
       +
           /// The Apple Music link of the playlist.

     

       26
       26
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       27
       27
       +
           #[builder(into)]

     

       28
       28
       +
           #[serde(borrow)]

     

       29
       29
       +
           pub apple_music_link: Option<jacquard_common::CowStr<'a>>,

     

       30
       30
       +
           /// The date the playlist was created.

     

       31
       31
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       32
       32
       +
           /// The playlist description.

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           #[builder(into)]

     

       35
       35
       +
           #[serde(borrow)]

     

       36
       36
       +
           pub description: Option<jacquard_common::CowStr<'a>>,

     

       37
       37
       +
           /// The name of the playlist.

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           #[builder(into)]

     

       40
       40
       +
           pub name: jacquard_common::CowStr<'a>,

     

       41
       41
       +
           /// The picture of the playlist.

     

       42
       42
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
       +
           #[builder(into)]

     

       44
       44
       +
           #[serde(borrow)]

     

       45
       45
       +
           pub picture: Option<jacquard_common::types::blob::Blob<'a>>,

     

       46
       46
       +
           /// The Spotify link of the playlist.

     

       47
       47
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
       +
           #[builder(into)]

     

       49
       49
       +
           #[serde(borrow)]

     

       50
       50
       +
           pub spotify_link: Option<jacquard_common::CowStr<'a>>,

     

       51
       51
       +
           /// The Tidal link of the playlist.

     

       52
       52
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       53
       53
       +
           #[builder(into)]

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           pub tidal_link: Option<jacquard_common::CowStr<'a>>,

     

       56
       56
       +
           /// The tracks in the playlist.

     

       57
       57
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       58
       58
       +
           #[builder(into)]

     

       59
       59
       +
           #[serde(borrow)]

     

       60
       60
       +
           pub tracks: Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       61
       61
       +
           /// The YouTube link of the playlist.

     

       62
       62
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       63
       63
       +
           #[builder(into)]

     

       64
       64
       +
           #[serde(borrow)]

     

       65
       65
       +
           pub youtube_link: Option<jacquard_common::CowStr<'a>>,

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       69
       69
       +
       #[derive(

     

       70
       70
       +
           serde::Serialize,

     

       71
       71
       +
           serde::Deserialize,

     

       72
       72
       +
           Debug,

     

       73
       73
       +
           Clone,

     

       74
       74
       +
           PartialEq,

     

       75
       75
       +
           Eq,

     

       76
       76
       +
           jacquard_derive::IntoStatic

     

       77
       77
       +
       )]

     

       78
       78
       +
       #[serde(rename_all = "camelCase")]

     

       79
       79
       +
       pub struct PlaylistGetRecordOutput<'a> {

     

       80
       80
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       81
       81
       +
           #[serde(borrow)]

     

       82
       82
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       83
       83
       +
           #[serde(borrow)]

     

       84
       84
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       85
       85
       +
           #[serde(borrow)]

     

       86
       86
       +
           pub value: Playlist<'a>,

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       /// Marker type for deserializing records from this collection.

     

       90
       90
       +
       pub struct PlaylistRecord;

     

       91
       91
       +
       impl jacquard_common::xrpc::XrpcResp for PlaylistRecord {

     

       92
       92
       +
           const NSID: &'static str = "app.rocksky.playlist";

     

       93
       93
       +
           const ENCODING: &'static str = "application/json";

     

       94
       94
       +
           type Output<'de> = PlaylistGetRecordOutput<'de>;

     

       95
       95
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       96
       96
       +
       }

     

       97
       97
       +
       

     

       98
       98
       +
       impl jacquard_common::types::collection::Collection for Playlist<'_> {

     

       99
       99
       +
           const NSID: &'static str = "app.rocksky.playlist";

     

       100
       100
       +
           type Record = PlaylistRecord;

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       impl From<PlaylistGetRecordOutput<'_>> for Playlist<'_> {

     

       104
       104
       +
           fn from(output: PlaylistGetRecordOutput<'_>) -> Self {

     

       105
       105
       +
               use jacquard_common::IntoStatic;

     

       106
       106
       +
               output.value.into_static()

     

       107
       107
       +
           }

     

       108
       108
       +
       }

     

       109
       109
       +
       

     

       110
       110
       +
       /// Basic view of a playlist, including its metadata

     

       111
       111
       +
       #[jacquard_derive::lexicon]

     

       112
       112
       +
       #[derive(

     

       113
       113
       +
           serde::Serialize,

     

       114
       114
       +
           serde::Deserialize,

     

       115
       115
       +
           Debug,

     

       116
       116
       +
           Clone,

     

       117
       117
       +
           PartialEq,

     

       118
       118
       +
           Eq,

     

       119
       119
       +
           jacquard_derive::IntoStatic,

     

       120
       120
       +
           Default

     

       121
       121
       +
       )]

     

       122
       122
       +
       #[serde(rename_all = "camelCase")]

     

       123
       123
       +
       pub struct PlaylistViewBasic<'a> {

     

       124
       124
       +
           /// The URL of the cover image for the playlist.

     

       125
       125
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       126
       126
       +
           #[serde(borrow)]

     

       127
       127
       +
           pub cover_image_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       128
       128
       +
           /// The date and time when the playlist was created.

     

       129
       129
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       130
       130
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       131
       131
       +
           /// The URL of the avatar image of the curator.

     

       132
       132
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       133
       133
       +
           #[serde(borrow)]

     

       134
       134
       +
           pub curator_avatar_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       135
       135
       +
           /// The DID of the curator of the playlist.

     

       136
       136
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       137
       137
       +
           #[serde(borrow)]

     

       138
       138
       +
           pub curator_did: std::option::Option<

     

       139
       139
       +
               jacquard_common::types::ident::AtIdentifier<'a>,

     

       140
       140
       +
           >,

     

       141
       141
       +
           /// The handle of the curator of the playlist.

     

       142
       142
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       143
       143
       +
           #[serde(borrow)]

     

       144
       144
       +
           pub curator_handle: std::option::Option<

     

       145
       145
       +
               jacquard_common::types::ident::AtIdentifier<'a>,

     

       146
       146
       +
           >,

     

       147
       147
       +
           /// The name of the curator of the playlist.

     

       148
       148
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       149
       149
       +
           #[serde(borrow)]

     

       150
       150
       +
           pub curator_name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       151
       151
       +
           /// A description of the playlist.

     

       152
       152
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       153
       153
       +
           #[serde(borrow)]

     

       154
       154
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       155
       155
       +
           /// The unique identifier of the playlist.

     

       156
       156
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       157
       157
       +
           #[serde(borrow)]

     

       158
       158
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       159
       159
       +
           /// The title of the playlist.

     

       160
       160
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       161
       161
       +
           #[serde(borrow)]

     

       162
       162
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       163
       163
       +
           /// The number of tracks in the playlist.

     

       164
       164
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       165
       165
       +
           pub track_count: std::option::Option<i64>,

     

       166
       166
       +
           /// The URI of the playlist.

     

       167
       167
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       168
       168
       +
           #[serde(borrow)]

     

       169
       169
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       /// Detailed view of a playlist, including its tracks and metadata

     

       173
       173
       +
       #[jacquard_derive::lexicon]

     

       174
       174
       +
       #[derive(

     

       175
       175
       +
           serde::Serialize,

     

       176
       176
       +
           serde::Deserialize,

     

       177
       177
       +
           Debug,

     

       178
       178
       +
           Clone,

     

       179
       179
       +
           PartialEq,

     

       180
       180
       +
           Eq,

     

       181
       181
       +
           jacquard_derive::IntoStatic,

     

       182
       182
       +
           Default

     

       183
       183
       +
       )]

     

       184
       184
       +
       #[serde(rename_all = "camelCase")]

     

       185
       185
       +
       pub struct PlaylistViewDetailed<'a> {

     

       186
       186
       +
           /// The URL of the cover image for the playlist.

     

       187
       187
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       188
       188
       +
           #[serde(borrow)]

     

       189
       189
       +
           pub cover_image_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       190
       190
       +
           /// The date and time when the playlist was created.

     

       191
       191
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       192
       192
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       193
       193
       +
           /// The URL of the avatar image of the curator.

     

       194
       194
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       195
       195
       +
           #[serde(borrow)]

     

       196
       196
       +
           pub curator_avatar_url: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       197
       197
       +
           /// The DID of the curator of the playlist.

     

       198
       198
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       199
       199
       +
           #[serde(borrow)]

     

       200
       200
       +
           pub curator_did: std::option::Option<

     

       201
       201
       +
               jacquard_common::types::ident::AtIdentifier<'a>,

     

       202
       202
       +
           >,

     

       203
       203
       +
           /// The handle of the curator of the playlist.

     

       204
       204
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       205
       205
       +
           #[serde(borrow)]

     

       206
       206
       +
           pub curator_handle: std::option::Option<

     

       207
       207
       +
               jacquard_common::types::ident::AtIdentifier<'a>,

     

       208
       208
       +
           >,

     

       209
       209
       +
           /// The name of the curator of the playlist.

     

       210
       210
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       211
       211
       +
           #[serde(borrow)]

     

       212
       212
       +
           pub curator_name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       213
       213
       +
           /// A description of the playlist.

     

       214
       214
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       215
       215
       +
           #[serde(borrow)]

     

       216
       216
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       217
       217
       +
           /// The unique identifier of the playlist.

     

       218
       218
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       219
       219
       +
           #[serde(borrow)]

     

       220
       220
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       221
       221
       +
           /// The title of the playlist.

     

       222
       222
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       223
       223
       +
           #[serde(borrow)]

     

       224
       224
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       225
       225
       +
           /// A list of tracks in the playlist.

     

       226
       226
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       227
       227
       +
           #[serde(borrow)]

     

       228
       228
       +
           pub tracks: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       229
       229
       +
           /// The URI of the playlist.

     

       230
       230
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       231
       231
       +
           #[serde(borrow)]

     

       232
       232
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       233
       233
       +
       }

+169

crates/jacquard-api/src/app_rocksky/radio.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.radio.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// A declaration of a radio station.

     

       9
       9
       +
       #[jacquard_derive::lexicon]

     

       10
       10
       +
       #[derive(

     

       11
       11
       +
           serde::Serialize,

     

       12
       12
       +
           serde::Deserialize,

     

       13
       13
       +
           Debug,

     

       14
       14
       +
           Clone,

     

       15
       15
       +
           PartialEq,

     

       16
       16
       +
           Eq,

     

       17
       17
       +
           jacquard_derive::IntoStatic,

     

       18
       18
       +
           bon::Builder

     

       19
       19
       +
       )]

     

       20
       20
       +
       #[serde(rename_all = "camelCase")]

     

       21
       21
       +
       pub struct Radio<'a> {

     

       22
       22
       +
           /// The date when the radio station was created.

     

       23
       23
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       24
       24
       +
           /// A description of the radio station.

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           #[builder(into)]

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub description: Option<jacquard_common::CowStr<'a>>,

     

       29
       29
       +
           /// The genre of the radio station.

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[builder(into)]

     

       32
       32
       +
           #[serde(borrow)]

     

       33
       33
       +
           pub genre: Option<jacquard_common::CowStr<'a>>,

     

       34
       34
       +
           /// The logo of the radio station.

     

       35
       35
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       36
       36
       +
           #[builder(into)]

     

       37
       37
       +
           #[serde(borrow)]

     

       38
       38
       +
           pub logo: Option<jacquard_common::types::blob::Blob<'a>>,

     

       39
       39
       +
           /// The name of the radio station.

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           #[builder(into)]

     

       42
       42
       +
           pub name: jacquard_common::CowStr<'a>,

     

       43
       43
       +
           /// The URL of the radio station.

     

       44
       44
       +
           #[serde(borrow)]

     

       45
       45
       +
           pub url: jacquard_common::types::string::Uri<'a>,

     

       46
       46
       +
           /// The website of the radio station.

     

       47
       47
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       48
       48
       +
           #[builder(into)]

     

       49
       49
       +
           #[serde(borrow)]

     

       50
       50
       +
           pub website: Option<jacquard_common::types::string::Uri<'a>>,

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       54
       54
       +
       #[derive(

     

       55
       55
       +
           serde::Serialize,

     

       56
       56
       +
           serde::Deserialize,

     

       57
       57
       +
           Debug,

     

       58
       58
       +
           Clone,

     

       59
       59
       +
           PartialEq,

     

       60
       60
       +
           Eq,

     

       61
       61
       +
           jacquard_derive::IntoStatic

     

       62
       62
       +
       )]

     

       63
       63
       +
       #[serde(rename_all = "camelCase")]

     

       64
       64
       +
       pub struct RadioGetRecordOutput<'a> {

     

       65
       65
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       66
       66
       +
           #[serde(borrow)]

     

       67
       67
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       68
       68
       +
           #[serde(borrow)]

     

       69
       69
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       70
       70
       +
           #[serde(borrow)]

     

       71
       71
       +
           pub value: Radio<'a>,

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       /// Marker type for deserializing records from this collection.

     

       75
       75
       +
       pub struct RadioRecord;

     

       76
       76
       +
       impl jacquard_common::xrpc::XrpcResp for RadioRecord {

     

       77
       77
       +
           const NSID: &'static str = "app.rocksky.radio";

     

       78
       78
       +
           const ENCODING: &'static str = "application/json";

     

       79
       79
       +
           type Output<'de> = RadioGetRecordOutput<'de>;

     

       80
       80
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       impl jacquard_common::types::collection::Collection for Radio<'_> {

     

       84
       84
       +
           const NSID: &'static str = "app.rocksky.radio";

     

       85
       85
       +
           type Record = RadioRecord;

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       impl From<RadioGetRecordOutput<'_>> for Radio<'_> {

     

       89
       89
       +
           fn from(output: RadioGetRecordOutput<'_>) -> Self {

     

       90
       90
       +
               use jacquard_common::IntoStatic;

     

       91
       91
       +
               output.value.into_static()

     

       92
       92
       +
           }

     

       93
       93
       +
       }

     

       94
       94
       +
       

     

       95
       95
       +
       #[jacquard_derive::lexicon]

     

       96
       96
       +
       #[derive(

     

       97
       97
       +
           serde::Serialize,

     

       98
       98
       +
           serde::Deserialize,

     

       99
       99
       +
           Debug,

     

       100
       100
       +
           Clone,

     

       101
       101
       +
           PartialEq,

     

       102
       102
       +
           Eq,

     

       103
       103
       +
           jacquard_derive::IntoStatic,

     

       104
       104
       +
           Default

     

       105
       105
       +
       )]

     

       106
       106
       +
       #[serde(rename_all = "camelCase")]

     

       107
       107
       +
       pub struct RadioViewBasic<'a> {

     

       108
       108
       +
           /// The date and time when the radio was created.

     

       109
       109
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       110
       110
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       111
       111
       +
           /// A brief description of the radio.

     

       112
       112
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       113
       113
       +
           #[serde(borrow)]

     

       114
       114
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       115
       115
       +
           /// The unique identifier of the radio.

     

       116
       116
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       117
       117
       +
           #[serde(borrow)]

     

       118
       118
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       119
       119
       +
           /// The name of the radio.

     

       120
       120
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       121
       121
       +
           #[serde(borrow)]

     

       122
       122
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       123
       123
       +
       }

     

       124
       124
       +
       

     

       125
       125
       +
       #[jacquard_derive::lexicon]

     

       126
       126
       +
       #[derive(

     

       127
       127
       +
           serde::Serialize,

     

       128
       128
       +
           serde::Deserialize,

     

       129
       129
       +
           Debug,

     

       130
       130
       +
           Clone,

     

       131
       131
       +
           PartialEq,

     

       132
       132
       +
           Eq,

     

       133
       133
       +
           jacquard_derive::IntoStatic,

     

       134
       134
       +
           Default

     

       135
       135
       +
       )]

     

       136
       136
       +
       #[serde(rename_all = "camelCase")]

     

       137
       137
       +
       pub struct RadioViewDetailed<'a> {

     

       138
       138
       +
           /// The date and time when the radio was created.

     

       139
       139
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       140
       140
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       141
       141
       +
           /// A brief description of the radio.

     

       142
       142
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       143
       143
       +
           #[serde(borrow)]

     

       144
       144
       +
           pub description: std::option::Option<jacquard_common::CowStr<'a>>,

     

       145
       145
       +
           /// The genre of the radio.

     

       146
       146
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       147
       147
       +
           #[serde(borrow)]

     

       148
       148
       +
           pub genre: std::option::Option<jacquard_common::CowStr<'a>>,

     

       149
       149
       +
           /// The unique identifier of the radio.

     

       150
       150
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       151
       151
       +
           #[serde(borrow)]

     

       152
       152
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       153
       153
       +
           /// The logo of the radio station.

     

       154
       154
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       155
       155
       +
           #[serde(borrow)]

     

       156
       156
       +
           pub logo: std::option::Option<jacquard_common::CowStr<'a>>,

     

       157
       157
       +
           /// The name of the radio.

     

       158
       158
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       159
       159
       +
           #[serde(borrow)]

     

       160
       160
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       161
       161
       +
           /// The streaming URL of the radio.

     

       162
       162
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       163
       163
       +
           #[serde(borrow)]

     

       164
       164
       +
           pub url: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       165
       165
       +
           /// The website of the radio.

     

       166
       166
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       167
       167
       +
           #[serde(borrow)]

     

       168
       168
       +
           pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       169
       169
       +
       }

+149

crates/jacquard-api/src/app_rocksky/scrobble/create_scrobble.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.scrobble.createScrobble

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct CreateScrobble<'a> {

     

       21
       21
       +
           /// The album of the track being scrobbled

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
           /// The URL of the album art for the track

     

       26
       26
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       29
       29
       +
           /// The Apple Music link for the track, if available

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           #[serde(borrow)]

     

       32
       32
       +
           pub apple_music_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       33
       33
       +
           /// The artist of the track being scrobbled

     

       34
       34
       +
           #[serde(borrow)]

     

       35
       35
       +
           pub artist: jacquard_common::CowStr<'a>,

     

       36
       36
       +
           /// The URL of the artist's picture, if available

     

       37
       37
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub artist_picture: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       40
       40
       +
           /// The composer of the track, if available

     

       41
       41
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub composer: std::option::Option<jacquard_common::CowStr<'a>>,

     

       44
       44
       +
           /// The copyright message for the track, if available

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub copyright_message: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
       +
           /// The Deezer link for the track, if available

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[serde(borrow)]

     

       51
       51
       +
           pub deezer_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       52
       52
       +
           /// The disc number of the track in the album, if applicable

     

       53
       53
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       54
       54
       +
           pub disc_number: std::option::Option<i64>,

     

       55
       55
       +
           /// The duration of the track in seconds

     

       56
       56
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       57
       57
       +
           pub duration: std::option::Option<i64>,

     

       58
       58
       +
           /// The record label of the track, if available

     

       59
       59
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       60
       60
       +
           #[serde(borrow)]

     

       61
       61
       +
           pub label: std::option::Option<jacquard_common::CowStr<'a>>,

     

       62
       62
       +
           /// The Last.fm link for the track, if available

     

       63
       63
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       64
       64
       +
           #[serde(borrow)]

     

       65
       65
       +
           pub lastfm_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       66
       66
       +
           /// The lyrics of the track, if available

     

       67
       67
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       68
       68
       +
           #[serde(borrow)]

     

       69
       69
       +
           pub lyrics: std::option::Option<jacquard_common::CowStr<'a>>,

     

       70
       70
       +
           /// The MusicBrainz ID of the track, if available

     

       71
       71
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       72
       72
       +
           #[serde(borrow)]

     

       73
       73
       +
           pub mb_id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       74
       74
       +
           /// The release date of the track, formatted as YYYY-MM-DD

     

       75
       75
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       76
       76
       +
           #[serde(borrow)]

     

       77
       77
       +
           pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,

     

       78
       78
       +
           /// The Spotify link for the track, if available

     

       79
       79
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       80
       80
       +
           #[serde(borrow)]

     

       81
       81
       +
           pub spotify_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       82
       82
       +
           /// The Tidal link for the track, if available

     

       83
       83
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       84
       84
       +
           #[serde(borrow)]

     

       85
       85
       +
           pub tidal_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       86
       86
       +
           /// The timestamp of the scrobble in milliseconds since epoch

     

       87
       87
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       88
       88
       +
           pub timestamp: std::option::Option<i64>,

     

       89
       89
       +
           /// The title of the track being scrobbled

     

       90
       90
       +
           #[serde(borrow)]

     

       91
       91
       +
           pub title: jacquard_common::CowStr<'a>,

     

       92
       92
       +
           /// The track number of the track in the album

     

       93
       93
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       94
       94
       +
           pub track_number: std::option::Option<i64>,

     

       95
       95
       +
           /// The year the track was released

     

       96
       96
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       97
       97
       +
           pub year: std::option::Option<i64>,

     

       98
       98
       +
           /// The Youtube link for the track, if available

     

       99
       99
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       100
       100
       +
           #[serde(borrow)]

     

       101
       101
       +
           pub youtube_link: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       #[jacquard_derive::lexicon]

     

       105
       105
       +
       #[derive(

     

       106
       106
       +
           serde::Serialize,

     

       107
       107
       +
           serde::Deserialize,

     

       108
       108
       +
           Debug,

     

       109
       109
       +
           Clone,

     

       110
       110
       +
           PartialEq,

     

       111
       111
       +
           Eq,

     

       112
       112
       +
           jacquard_derive::IntoStatic

     

       113
       113
       +
       )]

     

       114
       114
       +
       #[serde(rename_all = "camelCase")]

     

       115
       115
       +
       pub struct CreateScrobbleOutput<'a> {

     

       116
       116
       +
           #[serde(flatten)]

     

       117
       117
       +
           #[serde(borrow)]

     

       118
       118
       +
           pub value: crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>,

     

       119
       119
       +
       }

     

       120
       120
       +
       

     

       121
       121
       +
       ///Response type for

     

       122
       122
       +
       ///app.rocksky.scrobble.createScrobble

     

       123
       123
       +
       pub struct CreateScrobbleResponse;

     

       124
       124
       +
       impl jacquard_common::xrpc::XrpcResp for CreateScrobbleResponse {

     

       125
       125
       +
           const NSID: &'static str = "app.rocksky.scrobble.createScrobble";

     

       126
       126
       +
           const ENCODING: &'static str = "application/json";

     

       127
       127
       +
           type Output<'de> = CreateScrobbleOutput<'de>;

     

       128
       128
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for CreateScrobble<'a> {

     

       132
       132
       +
           const NSID: &'static str = "app.rocksky.scrobble.createScrobble";

     

       133
       133
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       134
       134
       +
               "application/json",

     

       135
       135
       +
           );

     

       136
       136
       +
           type Response = CreateScrobbleResponse;

     

       137
       137
       +
       }

     

       138
       138
       +
       

     

       139
       139
       +
       ///Endpoint type for

     

       140
       140
       +
       ///app.rocksky.scrobble.createScrobble

     

       141
       141
       +
       pub struct CreateScrobbleRequest;

     

       142
       142
       +
       impl jacquard_common::xrpc::XrpcEndpoint for CreateScrobbleRequest {

     

       143
       143
       +
           const PATH: &'static str = "/xrpc/app.rocksky.scrobble.createScrobble";

     

       144
       144
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       145
       145
       +
               "application/json",

     

       146
       146
       +
           );

     

       147
       147
       +
           type Request<'de> = CreateScrobble<'de>;

     

       148
       148
       +
           type Response = CreateScrobbleResponse;

     

       149
       149
       +
       }

+66

crates/jacquard-api/src/app_rocksky/scrobble/get_scrobble.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.scrobble.getScrobble

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetScrobble<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetScrobbleOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::scrobble::ScrobbleViewDetailed<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.scrobble.getScrobble

     

       44
       44
       +
       pub struct GetScrobbleResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetScrobbleResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.scrobble.getScrobble";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetScrobbleOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobble<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.scrobble.getScrobble";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetScrobbleResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.scrobble.getScrobble

     

       60
       60
       +
       pub struct GetScrobbleRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetScrobbleRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.scrobble.getScrobble";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetScrobble<'de>;

     

       65
       65
       +
           type Response = GetScrobbleResponse;

     

       66
       66
       +
       }

+76

crates/jacquard-api/src/app_rocksky/scrobble/get_scrobbles.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.scrobble.getScrobbles

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetScrobbles<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       24
       24
       +
           ///(min: 1)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub limit: std::option::Option<i64>,

     

       27
       27
       +
           ///(min: 0)

     

       28
       28
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       29
       29
       +
           pub offset: std::option::Option<i64>,

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       #[jacquard_derive::lexicon]

     

       33
       33
       +
       #[derive(

     

       34
       34
       +
           serde::Serialize,

     

       35
       35
       +
           serde::Deserialize,

     

       36
       36
       +
           Debug,

     

       37
       37
       +
           Clone,

     

       38
       38
       +
           PartialEq,

     

       39
       39
       +
           Eq,

     

       40
       40
       +
           jacquard_derive::IntoStatic,

     

       41
       41
       +
           Default

     

       42
       42
       +
       )]

     

       43
       43
       +
       #[serde(rename_all = "camelCase")]

     

       44
       44
       +
       pub struct GetScrobblesOutput<'a> {

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub scrobbles: std::option::Option<

     

       48
       48
       +
               Vec<crate::app_rocksky::scrobble::ScrobbleViewBasic<'a>>,

     

       49
       49
       +
           >,

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       ///Response type for

     

       53
       53
       +
       ///app.rocksky.scrobble.getScrobbles

     

       54
       54
       +
       pub struct GetScrobblesResponse;

     

       55
       55
       +
       impl jacquard_common::xrpc::XrpcResp for GetScrobblesResponse {

     

       56
       56
       +
           const NSID: &'static str = "app.rocksky.scrobble.getScrobbles";

     

       57
       57
       +
           const ENCODING: &'static str = "application/json";

     

       58
       58
       +
           type Output<'de> = GetScrobblesOutput<'de>;

     

       59
       59
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetScrobbles<'a> {

     

       63
       63
       +
           const NSID: &'static str = "app.rocksky.scrobble.getScrobbles";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Response = GetScrobblesResponse;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       ///Endpoint type for

     

       69
       69
       +
       ///app.rocksky.scrobble.getScrobbles

     

       70
       70
       +
       pub struct GetScrobblesRequest;

     

       71
       71
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetScrobblesRequest {

     

       72
       72
       +
           const PATH: &'static str = "/xrpc/app.rocksky.scrobble.getScrobbles";

     

       73
       73
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       74
       74
       +
           type Request<'de> = GetScrobbles<'de>;

     

       75
       75
       +
           type Response = GetScrobblesResponse;

     

       76
       76
       +
       }

+291

crates/jacquard-api/src/app_rocksky/scrobble.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.scrobble.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod create_scrobble;

     

       9
       9
       +
       pub mod get_scrobble;

     

       10
       10
       +
       pub mod get_scrobbles;

     

       11
       11
       +
       

     

       12
       12
       +
       /// A declaration of a scrobble.

     

       13
       13
       +
       #[jacquard_derive::lexicon]

     

       14
       14
       +
       #[derive(

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           Debug,

     

       18
       18
       +
           Clone,

     

       19
       19
       +
           PartialEq,

     

       20
       20
       +
           Eq,

     

       21
       21
       +
           jacquard_derive::IntoStatic,

     

       22
       22
       +
           bon::Builder

     

       23
       23
       +
       )]

     

       24
       24
       +
       #[serde(rename_all = "camelCase")]

     

       25
       25
       +
       pub struct Scrobble<'a> {

     

       26
       26
       +
           /// The album of the song.

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           #[builder(into)]

     

       29
       29
       +
           pub album: jacquard_common::CowStr<'a>,

     

       30
       30
       +
           /// The album art of the song.

     

       31
       31
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       32
       32
       +
           #[builder(into)]

     

       33
       33
       +
           #[serde(borrow)]

     

       34
       34
       +
           pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,

     

       35
       35
       +
           /// The album artist of the song.

     

       36
       36
       +
           #[serde(borrow)]

     

       37
       37
       +
           #[builder(into)]

     

       38
       38
       +
           pub album_artist: jacquard_common::CowStr<'a>,

     

       39
       39
       +
           /// The Apple Music link of the song.

     

       40
       40
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
       +
           #[builder(into)]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       44
       44
       +
           /// The artist of the song.

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           #[builder(into)]

     

       47
       47
       +
           pub artist: jacquard_common::CowStr<'a>,

     

       48
       48
       +
           /// The composer of the song.

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[builder(into)]

     

       51
       51
       +
           #[serde(borrow)]

     

       52
       52
       +
           pub composer: Option<jacquard_common::CowStr<'a>>,

     

       53
       53
       +
           /// The copyright message of the song.

     

       54
       54
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       55
       55
       +
           #[builder(into)]

     

       56
       56
       +
           #[serde(borrow)]

     

       57
       57
       +
           pub copyright_message: Option<jacquard_common::CowStr<'a>>,

     

       58
       58
       +
           /// The date when the song was created.

     

       59
       59
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       60
       60
       +
           /// The disc number of the song in the album.

     

       61
       61
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
       +
           #[builder(into)]

     

       63
       63
       +
           pub disc_number: Option<i64>,

     

       64
       64
       +
           /// The duration of the song in seconds.

     

       65
       65
       +
           pub duration: i64,

     

       66
       66
       +
           /// The genre of the song.

     

       67
       67
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       68
       68
       +
           #[builder(into)]

     

       69
       69
       +
           #[serde(borrow)]

     

       70
       70
       +
           pub genre: Option<jacquard_common::CowStr<'a>>,

     

       71
       71
       +
           /// The label of the song.

     

       72
       72
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       73
       73
       +
           #[builder(into)]

     

       74
       74
       +
           #[serde(borrow)]

     

       75
       75
       +
           pub label: Option<jacquard_common::CowStr<'a>>,

     

       76
       76
       +
           /// The lyrics of the song.

     

       77
       77
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       78
       78
       +
           #[builder(into)]

     

       79
       79
       +
           #[serde(borrow)]

     

       80
       80
       +
           pub lyrics: Option<jacquard_common::CowStr<'a>>,

     

       81
       81
       +
           /// The MusicBrainz ID of the song.

     

       82
       82
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       83
       83
       +
           #[builder(into)]

     

       84
       84
       +
           #[serde(borrow)]

     

       85
       85
       +
           pub mbid: Option<jacquard_common::CowStr<'a>>,

     

       86
       86
       +
           /// The release date of the song.

     

       87
       87
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       88
       88
       +
           #[builder(into)]

     

       89
       89
       +
           pub release_date: Option<jacquard_common::types::string::Datetime>,

     

       90
       90
       +
           /// The Spotify link of the song.

     

       91
       91
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       92
       92
       +
           #[builder(into)]

     

       93
       93
       +
           #[serde(borrow)]

     

       94
       94
       +
           pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       95
       95
       +
           /// The tags of the song.

     

       96
       96
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       97
       97
       +
           #[builder(into)]

     

       98
       98
       +
           #[serde(borrow)]

     

       99
       99
       +
           pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       100
       100
       +
           /// The Tidal link of the song.

     

       101
       101
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       102
       102
       +
           #[builder(into)]

     

       103
       103
       +
           #[serde(borrow)]

     

       104
       104
       +
           pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       105
       105
       +
           /// The title of the song.

     

       106
       106
       +
           #[serde(borrow)]

     

       107
       107
       +
           #[builder(into)]

     

       108
       108
       +
           pub title: jacquard_common::CowStr<'a>,

     

       109
       109
       +
           /// The track number of the song in the album.

     

       110
       110
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       111
       111
       +
           #[builder(into)]

     

       112
       112
       +
           pub track_number: Option<i64>,

     

       113
       113
       +
           /// Informations about the song

     

       114
       114
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       115
       115
       +
           #[builder(into)]

     

       116
       116
       +
           #[serde(borrow)]

     

       117
       117
       +
           pub wiki: Option<jacquard_common::CowStr<'a>>,

     

       118
       118
       +
           /// The year the song was released.

     

       119
       119
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       120
       120
       +
           #[builder(into)]

     

       121
       121
       +
           pub year: Option<i64>,

     

       122
       122
       +
           /// The YouTube link of the song.

     

       123
       123
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       124
       124
       +
           #[builder(into)]

     

       125
       125
       +
           #[serde(borrow)]

     

       126
       126
       +
           pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       127
       127
       +
       }

     

       128
       128
       +
       

     

       129
       129
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       130
       130
       +
       #[derive(

     

       131
       131
       +
           serde::Serialize,

     

       132
       132
       +
           serde::Deserialize,

     

       133
       133
       +
           Debug,

     

       134
       134
       +
           Clone,

     

       135
       135
       +
           PartialEq,

     

       136
       136
       +
           Eq,

     

       137
       137
       +
           jacquard_derive::IntoStatic

     

       138
       138
       +
       )]

     

       139
       139
       +
       #[serde(rename_all = "camelCase")]

     

       140
       140
       +
       pub struct ScrobbleGetRecordOutput<'a> {

     

       141
       141
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       142
       142
       +
           #[serde(borrow)]

     

       143
       143
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       144
       144
       +
           #[serde(borrow)]

     

       145
       145
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       146
       146
       +
           #[serde(borrow)]

     

       147
       147
       +
           pub value: Scrobble<'a>,

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       /// Marker type for deserializing records from this collection.

     

       151
       151
       +
       pub struct ScrobbleRecord;

     

       152
       152
       +
       impl jacquard_common::xrpc::XrpcResp for ScrobbleRecord {

     

       153
       153
       +
           const NSID: &'static str = "app.rocksky.scrobble";

     

       154
       154
       +
           const ENCODING: &'static str = "application/json";

     

       155
       155
       +
           type Output<'de> = ScrobbleGetRecordOutput<'de>;

     

       156
       156
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       impl jacquard_common::types::collection::Collection for Scrobble<'_> {

     

       160
       160
       +
           const NSID: &'static str = "app.rocksky.scrobble";

     

       161
       161
       +
           type Record = ScrobbleRecord;

     

       162
       162
       +
       }

     

       163
       163
       +
       

     

       164
       164
       +
       impl From<ScrobbleGetRecordOutput<'_>> for Scrobble<'_> {

     

       165
       165
       +
           fn from(output: ScrobbleGetRecordOutput<'_>) -> Self {

     

       166
       166
       +
               use jacquard_common::IntoStatic;

     

       167
       167
       +
               output.value.into_static()

     

       168
       168
       +
           }

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       #[jacquard_derive::lexicon]

     

       172
       172
       +
       #[derive(

     

       173
       173
       +
           serde::Serialize,

     

       174
       174
       +
           serde::Deserialize,

     

       175
       175
       +
           Debug,

     

       176
       176
       +
           Clone,

     

       177
       177
       +
           PartialEq,

     

       178
       178
       +
           Eq,

     

       179
       179
       +
           jacquard_derive::IntoStatic,

     

       180
       180
       +
           Default

     

       181
       181
       +
       )]

     

       182
       182
       +
       #[serde(rename_all = "camelCase")]

     

       183
       183
       +
       pub struct ScrobbleViewBasic<'a> {

     

       184
       184
       +
           /// The album of the song.

     

       185
       185
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       186
       186
       +
           #[serde(borrow)]

     

       187
       187
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       188
       188
       +
           /// The URI of the album.

     

       189
       189
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       190
       190
       +
           #[serde(borrow)]

     

       191
       191
       +
           pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       192
       192
       +
           /// The artist of the song.

     

       193
       193
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       194
       194
       +
           #[serde(borrow)]

     

       195
       195
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       196
       196
       +
           /// The URI of the artist.

     

       197
       197
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       198
       198
       +
           #[serde(borrow)]

     

       199
       199
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       200
       200
       +
           /// The album art URL of the song.

     

       201
       201
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       202
       202
       +
           #[serde(borrow)]

     

       203
       203
       +
           pub cover: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       204
       204
       +
           /// The timestamp when the scrobble was created.

     

       205
       205
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       206
       206
       +
           pub date: std::option::Option<jacquard_common::types::string::Datetime>,

     

       207
       207
       +
           /// The unique identifier of the scrobble.

     

       208
       208
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       209
       209
       +
           #[serde(borrow)]

     

       210
       210
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       211
       211
       +
           /// The SHA256 hash of the scrobble data.

     

       212
       212
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       213
       213
       +
           #[serde(borrow)]

     

       214
       214
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       215
       215
       +
           /// The title of the scrobble.

     

       216
       216
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       217
       217
       +
           #[serde(borrow)]

     

       218
       218
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       219
       219
       +
           /// The URI of the scrobble.

     

       220
       220
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       221
       221
       +
           #[serde(borrow)]

     

       222
       222
       +
           pub uri: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       223
       223
       +
           /// The handle of the user who created the scrobble.

     

       224
       224
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       225
       225
       +
           #[serde(borrow)]

     

       226
       226
       +
           pub user: std::option::Option<jacquard_common::CowStr<'a>>,

     

       227
       227
       +
       }

     

       228
       228
       +
       

     

       229
       229
       +
       #[jacquard_derive::lexicon]

     

       230
       230
       +
       #[derive(

     

       231
       231
       +
           serde::Serialize,

     

       232
       232
       +
           serde::Deserialize,

     

       233
       233
       +
           Debug,

     

       234
       234
       +
           Clone,

     

       235
       235
       +
           PartialEq,

     

       236
       236
       +
           Eq,

     

       237
       237
       +
           jacquard_derive::IntoStatic,

     

       238
       238
       +
           Default

     

       239
       239
       +
       )]

     

       240
       240
       +
       #[serde(rename_all = "camelCase")]

     

       241
       241
       +
       pub struct ScrobbleViewDetailed<'a> {

     

       242
       242
       +
           /// The album of the song.

     

       243
       243
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       244
       244
       +
           #[serde(borrow)]

     

       245
       245
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       246
       246
       +
           /// The URI of the album.

     

       247
       247
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       248
       248
       +
           #[serde(borrow)]

     

       249
       249
       +
           pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       250
       250
       +
           /// The artist of the song.

     

       251
       251
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       252
       252
       +
           #[serde(borrow)]

     

       253
       253
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       254
       254
       +
           /// The URI of the artist.

     

       255
       255
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       256
       256
       +
           #[serde(borrow)]

     

       257
       257
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       258
       258
       +
           /// The album art URL of the song.

     

       259
       259
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       260
       260
       +
           #[serde(borrow)]

     

       261
       261
       +
           pub cover: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       262
       262
       +
           /// The timestamp when the scrobble was created.

     

       263
       263
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       264
       264
       +
           pub date: std::option::Option<jacquard_common::types::string::Datetime>,

     

       265
       265
       +
           /// The unique identifier of the scrobble.

     

       266
       266
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       267
       267
       +
           #[serde(borrow)]

     

       268
       268
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       269
       269
       +
           /// The number of listeners

     

       270
       270
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       271
       271
       +
           pub listeners: std::option::Option<i64>,

     

       272
       272
       +
           /// The number of scrobbles for this song

     

       273
       273
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       274
       274
       +
           pub scrobbles: std::option::Option<i64>,

     

       275
       275
       +
           /// The SHA256 hash of the scrobble data.

     

       276
       276
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       277
       277
       +
           #[serde(borrow)]

     

       278
       278
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       279
       279
       +
           /// The title of the scrobble.

     

       280
       280
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       281
       281
       +
           #[serde(borrow)]

     

       282
       282
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       283
       283
       +
           /// The URI of the scrobble.

     

       284
       284
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       285
       285
       +
           #[serde(borrow)]

     

       286
       286
       +
           pub uri: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       287
       287
       +
           /// The handle of the user who created the scrobble.

     

       288
       288
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       289
       289
       +
           #[serde(borrow)]

     

       290
       290
       +
           pub user: std::option::Option<jacquard_common::CowStr<'a>>,

     

       291
       291
       +
       }

+72

crates/jacquard-api/src/app_rocksky/shout/create_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.createShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct CreateShout<'a> {

     

       21
       21
       +
           /// The content of the shout

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub message: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       #[jacquard_derive::lexicon]

     

       28
       28
       +
       #[derive(

     

       29
       29
       +
           serde::Serialize,

     

       30
       30
       +
           serde::Deserialize,

     

       31
       31
       +
           Debug,

     

       32
       32
       +
           Clone,

     

       33
       33
       +
           PartialEq,

     

       34
       34
       +
           Eq,

     

       35
       35
       +
           jacquard_derive::IntoStatic

     

       36
       36
       +
       )]

     

       37
       37
       +
       #[serde(rename_all = "camelCase")]

     

       38
       38
       +
       pub struct CreateShoutOutput<'a> {

     

       39
       39
       +
           #[serde(flatten)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       ///Response type for

     

       45
       45
       +
       ///app.rocksky.shout.createShout

     

       46
       46
       +
       pub struct CreateShoutResponse;

     

       47
       47
       +
       impl jacquard_common::xrpc::XrpcResp for CreateShoutResponse {

     

       48
       48
       +
           const NSID: &'static str = "app.rocksky.shout.createShout";

     

       49
       49
       +
           const ENCODING: &'static str = "application/json";

     

       50
       50
       +
           type Output<'de> = CreateShoutOutput<'de>;

     

       51
       51
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for CreateShout<'a> {

     

       55
       55
       +
           const NSID: &'static str = "app.rocksky.shout.createShout";

     

       56
       56
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       57
       57
       +
               "application/json",

     

       58
       58
       +
           );

     

       59
       59
       +
           type Response = CreateShoutResponse;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       ///Endpoint type for

     

       63
       63
       +
       ///app.rocksky.shout.createShout

     

       64
       64
       +
       pub struct CreateShoutRequest;

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcEndpoint for CreateShoutRequest {

     

       66
       66
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.createShout";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Request<'de> = CreateShout<'de>;

     

       71
       71
       +
           type Response = CreateShoutResponse;

     

       72
       72
       +
       }

+73

crates/jacquard-api/src/app_rocksky/shout/get_album_shouts.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.getAlbumShouts

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetAlbumShouts<'a> {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetAlbumShoutsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.shout.getAlbumShouts

     

       51
       51
       +
       pub struct GetAlbumShoutsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetAlbumShoutsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.shout.getAlbumShouts";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetAlbumShoutsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetAlbumShouts<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.shout.getAlbumShouts";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetAlbumShoutsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.shout.getAlbumShouts

     

       67
       67
       +
       pub struct GetAlbumShoutsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetAlbumShoutsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.getAlbumShouts";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetAlbumShouts<'de>;

     

       72
       72
       +
           type Response = GetAlbumShoutsResponse;

     

       73
       73
       +
       }

+73

crates/jacquard-api/src/app_rocksky/shout/get_artist_shouts.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.getArtistShouts

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetArtistShouts<'a> {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetArtistShoutsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.shout.getArtistShouts

     

       51
       51
       +
       pub struct GetArtistShoutsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetArtistShoutsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.shout.getArtistShouts";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetArtistShoutsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetArtistShouts<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.shout.getArtistShouts";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetArtistShoutsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.shout.getArtistShouts

     

       67
       67
       +
       pub struct GetArtistShoutsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetArtistShoutsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.getArtistShouts";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetArtistShouts<'de>;

     

       72
       72
       +
           type Response = GetArtistShoutsResponse;

     

       73
       73
       +
       }

+73

crates/jacquard-api/src/app_rocksky/shout/get_profile_shouts.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.getProfileShouts

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetProfileShouts<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
           ///(min: 1)

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub limit: std::option::Option<i64>,

     

       26
       26
       +
           ///(min: 0)

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub offset: std::option::Option<i64>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetProfileShoutsOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.shout.getProfileShouts

     

       51
       51
       +
       pub struct GetProfileShoutsResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetProfileShoutsResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.shout.getProfileShouts";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetProfileShoutsOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetProfileShouts<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.shout.getProfileShouts";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetProfileShoutsResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.shout.getProfileShouts

     

       67
       67
       +
       pub struct GetProfileShoutsRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetProfileShoutsRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.getProfileShouts";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetProfileShouts<'de>;

     

       72
       72
       +
           type Response = GetProfileShoutsResponse;

     

       73
       73
       +
       }

+73

crates/jacquard-api/src/app_rocksky/shout/get_shout_replies.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.getShoutReplies

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetShoutReplies<'a> {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           Default

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct GetShoutRepliesOutput<'a> {

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       ///Response type for

     

       50
       50
       +
       ///app.rocksky.shout.getShoutReplies

     

       51
       51
       +
       pub struct GetShoutRepliesResponse;

     

       52
       52
       +
       impl jacquard_common::xrpc::XrpcResp for GetShoutRepliesResponse {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.shout.getShoutReplies";

     

       54
       54
       +
           const ENCODING: &'static str = "application/json";

     

       55
       55
       +
           type Output<'de> = GetShoutRepliesOutput<'de>;

     

       56
       56
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetShoutReplies<'a> {

     

       60
       60
       +
           const NSID: &'static str = "app.rocksky.shout.getShoutReplies";

     

       61
       61
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       62
       62
       +
           type Response = GetShoutRepliesResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.shout.getShoutReplies

     

       67
       67
       +
       pub struct GetShoutRepliesRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetShoutRepliesRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.getShoutReplies";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       71
       71
       +
           type Request<'de> = GetShoutReplies<'de>;

     

       72
       72
       +
           type Response = GetShoutRepliesResponse;

     

       73
       73
       +
       }

+67

crates/jacquard-api/src/app_rocksky/shout/get_track_shouts.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.getTrackShouts

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetTrackShouts<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic,

     

       34
       34
       +
           Default

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetTrackShoutsOutput<'a> {

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub shouts: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.shout.getTrackShouts

     

       45
       45
       +
       pub struct GetTrackShoutsResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetTrackShoutsResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.shout.getTrackShouts";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetTrackShoutsOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetTrackShouts<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.shout.getTrackShouts";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetTrackShoutsResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.shout.getTrackShouts

     

       61
       61
       +
       pub struct GetTrackShoutsRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetTrackShoutsRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.getTrackShouts";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetTrackShouts<'de>;

     

       66
       66
       +
           type Response = GetTrackShoutsResponse;

     

       67
       67
       +
       }

+83

crates/jacquard-api/src/app_rocksky/shout/remove_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.removeShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct RemoveShoutParams<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           #[builder(into)]

     

       23
       23
       +
           pub id: jacquard_common::CowStr<'a>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct RemoveShoutOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       /// XRPC request marker type

     

       44
       44
       +
       #[derive(

     

       45
       45
       +
           Debug,

     

       46
       46
       +
           Clone,

     

       47
       47
       +
           Copy,

     

       48
       48
       +
           PartialEq,

     

       49
       49
       +
           Eq,

     

       50
       50
       +
           serde::Serialize,

     

       51
       51
       +
           serde::Deserialize,

     

       52
       52
       +
           jacquard_derive::IntoStatic

     

       53
       53
       +
       )]

     

       54
       54
       +
       pub struct RemoveShout;

     

       55
       55
       +
       ///Response type for

     

       56
       56
       +
       ///app.rocksky.shout.removeShout

     

       57
       57
       +
       pub struct RemoveShoutResponse;

     

       58
       58
       +
       impl jacquard_common::xrpc::XrpcResp for RemoveShoutResponse {

     

       59
       59
       +
           const NSID: &'static str = "app.rocksky.shout.removeShout";

     

       60
       60
       +
           const ENCODING: &'static str = "application/json";

     

       61
       61
       +
           type Output<'de> = RemoveShoutOutput<'de>;

     

       62
       62
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       impl jacquard_common::xrpc::XrpcRequest for RemoveShout {

     

       66
       66
       +
           const NSID: &'static str = "app.rocksky.shout.removeShout";

     

       67
       67
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       68
       68
       +
               "application/json",

     

       69
       69
       +
           );

     

       70
       70
       +
           type Response = RemoveShoutResponse;

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       ///Endpoint type for

     

       74
       74
       +
       ///app.rocksky.shout.removeShout

     

       75
       75
       +
       pub struct RemoveShoutRequest;

     

       76
       76
       +
       impl jacquard_common::xrpc::XrpcEndpoint for RemoveShoutRequest {

     

       77
       77
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.removeShout";

     

       78
       78
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       79
       79
       +
               "application/json",

     

       80
       80
       +
           );

     

       81
       81
       +
           type Request<'de> = RemoveShout;

     

       82
       82
       +
           type Response = RemoveShoutResponse;

     

       83
       83
       +
       }

+74

crates/jacquard-api/src/app_rocksky/shout/reply_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.replyShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct ReplyShout<'a> {

     

       21
       21
       +
           /// The content of the reply

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub message: jacquard_common::CowStr<'a>,

     

       24
       24
       +
           /// The unique identifier of the shout to reply to

     

       25
       25
       +
           #[serde(borrow)]

     

       26
       26
       +
           pub shout_id: jacquard_common::CowStr<'a>,

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       #[jacquard_derive::lexicon]

     

       30
       30
       +
       #[derive(

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           Debug,

     

       34
       34
       +
           Clone,

     

       35
       35
       +
           PartialEq,

     

       36
       36
       +
           Eq,

     

       37
       37
       +
           jacquard_derive::IntoStatic

     

       38
       38
       +
       )]

     

       39
       39
       +
       #[serde(rename_all = "camelCase")]

     

       40
       40
       +
       pub struct ReplyShoutOutput<'a> {

     

       41
       41
       +
           #[serde(flatten)]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       ///Response type for

     

       47
       47
       +
       ///app.rocksky.shout.replyShout

     

       48
       48
       +
       pub struct ReplyShoutResponse;

     

       49
       49
       +
       impl jacquard_common::xrpc::XrpcResp for ReplyShoutResponse {

     

       50
       50
       +
           const NSID: &'static str = "app.rocksky.shout.replyShout";

     

       51
       51
       +
           const ENCODING: &'static str = "application/json";

     

       52
       52
       +
           type Output<'de> = ReplyShoutOutput<'de>;

     

       53
       53
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for ReplyShout<'a> {

     

       57
       57
       +
           const NSID: &'static str = "app.rocksky.shout.replyShout";

     

       58
       58
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       59
       59
       +
               "application/json",

     

       60
       60
       +
           );

     

       61
       61
       +
           type Response = ReplyShoutResponse;

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       ///Endpoint type for

     

       65
       65
       +
       ///app.rocksky.shout.replyShout

     

       66
       66
       +
       pub struct ReplyShoutRequest;

     

       67
       67
       +
       impl jacquard_common::xrpc::XrpcEndpoint for ReplyShoutRequest {

     

       68
       68
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.replyShout";

     

       69
       69
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       70
       70
       +
               "application/json",

     

       71
       71
       +
           );

     

       72
       72
       +
           type Request<'de> = ReplyShout<'de>;

     

       73
       73
       +
           type Response = ReplyShoutResponse;

     

       74
       74
       +
       }

+75

crates/jacquard-api/src/app_rocksky/shout/report_shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.reportShout

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct ReportShout<'a> {

     

       21
       21
       +
           /// The reason for reporting the shout

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub reason: std::option::Option<jacquard_common::CowStr<'a>>,

     

       25
       25
       +
           /// The unique identifier of the shout to report

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub shout_id: jacquard_common::CowStr<'a>,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       #[jacquard_derive::lexicon]

     

       31
       31
       +
       #[derive(

     

       32
       32
       +
           serde::Serialize,

     

       33
       33
       +
           serde::Deserialize,

     

       34
       34
       +
           Debug,

     

       35
       35
       +
           Clone,

     

       36
       36
       +
           PartialEq,

     

       37
       37
       +
           Eq,

     

       38
       38
       +
           jacquard_derive::IntoStatic

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct ReportShoutOutput<'a> {

     

       42
       42
       +
           #[serde(flatten)]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub value: crate::app_rocksky::shout::ShoutView<'a>,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       ///Response type for

     

       48
       48
       +
       ///app.rocksky.shout.reportShout

     

       49
       49
       +
       pub struct ReportShoutResponse;

     

       50
       50
       +
       impl jacquard_common::xrpc::XrpcResp for ReportShoutResponse {

     

       51
       51
       +
           const NSID: &'static str = "app.rocksky.shout.reportShout";

     

       52
       52
       +
           const ENCODING: &'static str = "application/json";

     

       53
       53
       +
           type Output<'de> = ReportShoutOutput<'de>;

     

       54
       54
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for ReportShout<'a> {

     

       58
       58
       +
           const NSID: &'static str = "app.rocksky.shout.reportShout";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       60
       60
       +
               "application/json",

     

       61
       61
       +
           );

     

       62
       62
       +
           type Response = ReportShoutResponse;

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       ///Endpoint type for

     

       66
       66
       +
       ///app.rocksky.shout.reportShout

     

       67
       67
       +
       pub struct ReportShoutRequest;

     

       68
       68
       +
       impl jacquard_common::xrpc::XrpcEndpoint for ReportShoutRequest {

     

       69
       69
       +
           const PATH: &'static str = "/xrpc/app.rocksky.shout.reportShout";

     

       70
       70
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       71
       71
       +
               "application/json",

     

       72
       72
       +
           );

     

       73
       73
       +
           type Request<'de> = ReportShout<'de>;

     

       74
       74
       +
           type Response = ReportShoutResponse;

     

       75
       75
       +
       }

+155

crates/jacquard-api/src/app_rocksky/shout.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.shout.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod create_shout;

     

       9
       9
       +
       pub mod get_album_shouts;

     

       10
       10
       +
       pub mod get_artist_shouts;

     

       11
       11
       +
       pub mod get_profile_shouts;

     

       12
       12
       +
       pub mod get_shout_replies;

     

       13
       13
       +
       pub mod get_track_shouts;

     

       14
       14
       +
       pub mod remove_shout;

     

       15
       15
       +
       pub mod reply_shout;

     

       16
       16
       +
       pub mod report_shout;

     

       17
       17
       +
       

     

       18
       18
       +
       /// A declaration of a shout.

     

       19
       19
       +
       #[jacquard_derive::lexicon]

     

       20
       20
       +
       #[derive(

     

       21
       21
       +
           serde::Serialize,

     

       22
       22
       +
           serde::Deserialize,

     

       23
       23
       +
           Debug,

     

       24
       24
       +
           Clone,

     

       25
       25
       +
           PartialEq,

     

       26
       26
       +
           Eq,

     

       27
       27
       +
           jacquard_derive::IntoStatic,

     

       28
       28
       +
           bon::Builder

     

       29
       29
       +
       )]

     

       30
       30
       +
       #[serde(rename_all = "camelCase")]

     

       31
       31
       +
       pub struct Shout<'a> {

     

       32
       32
       +
           /// The date when the shout was created.

     

       33
       33
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       34
       34
       +
           /// The message of the shout.

     

       35
       35
       +
           #[serde(borrow)]

     

       36
       36
       +
           #[builder(into)]

     

       37
       37
       +
           pub message: jacquard_common::CowStr<'a>,

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           #[builder(into)]

     

       40
       40
       +
           #[serde(borrow)]

     

       41
       41
       +
           pub parent: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       47
       47
       +
       #[derive(

     

       48
       48
       +
           serde::Serialize,

     

       49
       49
       +
           serde::Deserialize,

     

       50
       50
       +
           Debug,

     

       51
       51
       +
           Clone,

     

       52
       52
       +
           PartialEq,

     

       53
       53
       +
           Eq,

     

       54
       54
       +
           jacquard_derive::IntoStatic

     

       55
       55
       +
       )]

     

       56
       56
       +
       #[serde(rename_all = "camelCase")]

     

       57
       57
       +
       pub struct ShoutGetRecordOutput<'a> {

     

       58
       58
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       59
       59
       +
           #[serde(borrow)]

     

       60
       60
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       61
       61
       +
           #[serde(borrow)]

     

       62
       62
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       63
       63
       +
           #[serde(borrow)]

     

       64
       64
       +
           pub value: Shout<'a>,

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       /// Marker type for deserializing records from this collection.

     

       68
       68
       +
       pub struct ShoutRecord;

     

       69
       69
       +
       impl jacquard_common::xrpc::XrpcResp for ShoutRecord {

     

       70
       70
       +
           const NSID: &'static str = "app.rocksky.shout";

     

       71
       71
       +
           const ENCODING: &'static str = "application/json";

     

       72
       72
       +
           type Output<'de> = ShoutGetRecordOutput<'de>;

     

       73
       73
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       74
       74
       +
       }

     

       75
       75
       +
       

     

       76
       76
       +
       impl jacquard_common::types::collection::Collection for Shout<'_> {

     

       77
       77
       +
           const NSID: &'static str = "app.rocksky.shout";

     

       78
       78
       +
           type Record = ShoutRecord;

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       impl From<ShoutGetRecordOutput<'_>> for Shout<'_> {

     

       82
       82
       +
           fn from(output: ShoutGetRecordOutput<'_>) -> Self {

     

       83
       83
       +
               use jacquard_common::IntoStatic;

     

       84
       84
       +
               output.value.into_static()

     

       85
       85
       +
           }

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       #[jacquard_derive::lexicon]

     

       89
       89
       +
       #[derive(

     

       90
       90
       +
           serde::Serialize,

     

       91
       91
       +
           serde::Deserialize,

     

       92
       92
       +
           Debug,

     

       93
       93
       +
           Clone,

     

       94
       94
       +
           PartialEq,

     

       95
       95
       +
           Eq,

     

       96
       96
       +
           jacquard_derive::IntoStatic,

     

       97
       97
       +
           Default

     

       98
       98
       +
       )]

     

       99
       99
       +
       #[serde(rename_all = "camelCase")]

     

       100
       100
       +
       pub struct Author<'a> {

     

       101
       101
       +
           /// The URL of the author's avatar image.

     

       102
       102
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       103
       103
       +
           #[serde(borrow)]

     

       104
       104
       +
           pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       105
       105
       +
           /// The decentralized identifier (DID) of the author.

     

       106
       106
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       107
       107
       +
           #[serde(borrow)]

     

       108
       108
       +
           pub did: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       109
       109
       +
           /// The display name of the author.

     

       110
       110
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       111
       111
       +
           #[serde(borrow)]

     

       112
       112
       +
           pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       113
       113
       +
           /// The handle of the author.

     

       114
       114
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       115
       115
       +
           #[serde(borrow)]

     

       116
       116
       +
           pub handle: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       117
       117
       +
           /// The unique identifier of the author.

     

       118
       118
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       119
       119
       +
           #[serde(borrow)]

     

       120
       120
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       121
       121
       +
       }

     

       122
       122
       +
       

     

       123
       123
       +
       #[jacquard_derive::lexicon]

     

       124
       124
       +
       #[derive(

     

       125
       125
       +
           serde::Serialize,

     

       126
       126
       +
           serde::Deserialize,

     

       127
       127
       +
           Debug,

     

       128
       128
       +
           Clone,

     

       129
       129
       +
           PartialEq,

     

       130
       130
       +
           Eq,

     

       131
       131
       +
           jacquard_derive::IntoStatic,

     

       132
       132
       +
           Default

     

       133
       133
       +
       )]

     

       134
       134
       +
       #[serde(rename_all = "camelCase")]

     

       135
       135
       +
       pub struct ShoutView<'a> {

     

       136
       136
       +
           /// The author of the shout.

     

       137
       137
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       138
       138
       +
           #[serde(borrow)]

     

       139
       139
       +
           pub author: std::option::Option<crate::app_rocksky::shout::Author<'a>>,

     

       140
       140
       +
           /// The date and time when the shout was created.

     

       141
       141
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       142
       142
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       143
       143
       +
           /// The unique identifier of the shout.

     

       144
       144
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       145
       145
       +
           #[serde(borrow)]

     

       146
       146
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       147
       147
       +
           /// The content of the shout.

     

       148
       148
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       149
       149
       +
           #[serde(borrow)]

     

       150
       150
       +
           pub message: std::option::Option<jacquard_common::CowStr<'a>>,

     

       151
       151
       +
           /// The ID of the parent shout if this is a reply, otherwise null.

     

       152
       152
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       153
       153
       +
           #[serde(borrow)]

     

       154
       154
       +
           pub parent: std::option::Option<jacquard_common::CowStr<'a>>,

     

       155
       155
       +
       }

+108

crates/jacquard-api/src/app_rocksky/song/create_song.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.song.createSong

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[jacquard_derive::lexicon]

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           serde::Serialize,

     

       11
       11
       +
           serde::Deserialize,

     

       12
       12
       +
           Debug,

     

       13
       13
       +
           Clone,

     

       14
       14
       +
           PartialEq,

     

       15
       15
       +
           Eq,

     

       16
       16
       +
           jacquard_derive::IntoStatic,

     

       17
       17
       +
           Default

     

       18
       18
       +
       )]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct CreateSong<'a> {

     

       21
       21
       +
           /// The album of the song, if applicable

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub album: jacquard_common::CowStr<'a>,

     

       24
       24
       +
           /// The URL of the album art for the song

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       28
       28
       +
           /// The album artist of the song, if different from the main artist

     

       29
       29
       +
           #[serde(borrow)]

     

       30
       30
       +
           pub album_artist: jacquard_common::CowStr<'a>,

     

       31
       31
       +
           /// The artist of the song

     

       32
       32
       +
           #[serde(borrow)]

     

       33
       33
       +
           pub artist: jacquard_common::CowStr<'a>,

     

       34
       34
       +
           /// The disc number of the song in the album, if applicable

     

       35
       35
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       36
       36
       +
           pub disc_number: std::option::Option<i64>,

     

       37
       37
       +
           /// The duration of the song in seconds

     

       38
       38
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       39
       39
       +
           pub duration: std::option::Option<i64>,

     

       40
       40
       +
           /// The lyrics of the song, if available

     

       41
       41
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub lyrics: std::option::Option<jacquard_common::CowStr<'a>>,

     

       44
       44
       +
           /// The MusicBrainz ID of the song, if available

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[serde(borrow)]

     

       47
       47
       +
           pub mb_id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       48
       48
       +
           /// The release date of the song, formatted as YYYY-MM-DD

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[serde(borrow)]

     

       51
       51
       +
           pub release_date: std::option::Option<jacquard_common::CowStr<'a>>,

     

       52
       52
       +
           /// The title of the song

     

       53
       53
       +
           #[serde(borrow)]

     

       54
       54
       +
           pub title: jacquard_common::CowStr<'a>,

     

       55
       55
       +
           /// The track number of the song in the album, if applicable

     

       56
       56
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       57
       57
       +
           pub track_number: std::option::Option<i64>,

     

       58
       58
       +
           /// The year the song was released

     

       59
       59
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       60
       60
       +
           pub year: std::option::Option<i64>,

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       #[jacquard_derive::lexicon]

     

       64
       64
       +
       #[derive(

     

       65
       65
       +
           serde::Serialize,

     

       66
       66
       +
           serde::Deserialize,

     

       67
       67
       +
           Debug,

     

       68
       68
       +
           Clone,

     

       69
       69
       +
           PartialEq,

     

       70
       70
       +
           Eq,

     

       71
       71
       +
           jacquard_derive::IntoStatic

     

       72
       72
       +
       )]

     

       73
       73
       +
       #[serde(rename_all = "camelCase")]

     

       74
       74
       +
       pub struct CreateSongOutput<'a> {

     

       75
       75
       +
           #[serde(flatten)]

     

       76
       76
       +
           #[serde(borrow)]

     

       77
       77
       +
           pub value: crate::app_rocksky::song::SongViewDetailed<'a>,

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       ///Response type for

     

       81
       81
       +
       ///app.rocksky.song.createSong

     

       82
       82
       +
       pub struct CreateSongResponse;

     

       83
       83
       +
       impl jacquard_common::xrpc::XrpcResp for CreateSongResponse {

     

       84
       84
       +
           const NSID: &'static str = "app.rocksky.song.createSong";

     

       85
       85
       +
           const ENCODING: &'static str = "application/json";

     

       86
       86
       +
           type Output<'de> = CreateSongOutput<'de>;

     

       87
       87
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for CreateSong<'a> {

     

       91
       91
       +
           const NSID: &'static str = "app.rocksky.song.createSong";

     

       92
       92
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       93
       93
       +
               "application/json",

     

       94
       94
       +
           );

     

       95
       95
       +
           type Response = CreateSongResponse;

     

       96
       96
       +
       }

     

       97
       97
       +
       

     

       98
       98
       +
       ///Endpoint type for

     

       99
       99
       +
       ///app.rocksky.song.createSong

     

       100
       100
       +
       pub struct CreateSongRequest;

     

       101
       101
       +
       impl jacquard_common::xrpc::XrpcEndpoint for CreateSongRequest {

     

       102
       102
       +
           const PATH: &'static str = "/xrpc/app.rocksky.song.createSong";

     

       103
       103
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       104
       104
       +
               "application/json",

     

       105
       105
       +
           );

     

       106
       106
       +
           type Request<'de> = CreateSong<'de>;

     

       107
       107
       +
           type Response = CreateSongResponse;

     

       108
       108
       +
       }

+66

crates/jacquard-api/src/app_rocksky/song/get_song.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.song.getSong

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetSong<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetSongOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::song::SongViewDetailed<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.song.getSong

     

       44
       44
       +
       pub struct GetSongResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetSongResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.song.getSong";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetSongOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetSong<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.song.getSong";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetSongResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.song.getSong

     

       60
       60
       +
       pub struct GetSongRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetSongRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.song.getSong";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetSong<'de>;

     

       65
       65
       +
           type Response = GetSongResponse;

     

       66
       66
       +
       }

+71

crates/jacquard-api/src/app_rocksky/song/get_songs.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.song.getSongs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetSongs {

     

       21
       21
       +
           ///(min: 1)

     

       22
       22
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       23
       23
       +
           pub limit: std::option::Option<i64>,

     

       24
       24
       +
           ///(min: 0)

     

       25
       25
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       26
       26
       +
           pub offset: std::option::Option<i64>,

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       #[jacquard_derive::lexicon]

     

       30
       30
       +
       #[derive(

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           Debug,

     

       34
       34
       +
           Clone,

     

       35
       35
       +
           PartialEq,

     

       36
       36
       +
           Eq,

     

       37
       37
       +
           jacquard_derive::IntoStatic,

     

       38
       38
       +
           Default

     

       39
       39
       +
       )]

     

       40
       40
       +
       #[serde(rename_all = "camelCase")]

     

       41
       41
       +
       pub struct GetSongsOutput<'a> {

     

       42
       42
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       43
       43
       +
           #[serde(borrow)]

     

       44
       44
       +
           pub songs: std::option::Option<Vec<crate::app_rocksky::song::SongViewBasic<'a>>>,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       ///Response type for

     

       48
       48
       +
       ///app.rocksky.song.getSongs

     

       49
       49
       +
       pub struct GetSongsResponse;

     

       50
       50
       +
       impl jacquard_common::xrpc::XrpcResp for GetSongsResponse {

     

       51
       51
       +
           const NSID: &'static str = "app.rocksky.song.getSongs";

     

       52
       52
       +
           const ENCODING: &'static str = "application/json";

     

       53
       53
       +
           type Output<'de> = GetSongsOutput<'de>;

     

       54
       54
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcRequest for GetSongs {

     

       58
       58
       +
           const NSID: &'static str = "app.rocksky.song.getSongs";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       60
       60
       +
           type Response = GetSongsResponse;

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       ///Endpoint type for

     

       64
       64
       +
       ///app.rocksky.song.getSongs

     

       65
       65
       +
       pub struct GetSongsRequest;

     

       66
       66
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetSongsRequest {

     

       67
       67
       +
           const PATH: &'static str = "/xrpc/app.rocksky.song.getSongs";

     

       68
       68
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       69
       69
       +
           type Request<'de> = GetSongs;

     

       70
       70
       +
           type Response = GetSongsResponse;

     

       71
       71
       +
       }

+315

crates/jacquard-api/src/app_rocksky/song.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.song.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod create_song;

     

       9
       9
       +
       pub mod get_song;

     

       10
       10
       +
       pub mod get_songs;

     

       11
       11
       +
       

     

       12
       12
       +
       /// A declaration of a song.

     

       13
       13
       +
       #[jacquard_derive::lexicon]

     

       14
       14
       +
       #[derive(

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           Debug,

     

       18
       18
       +
           Clone,

     

       19
       19
       +
           PartialEq,

     

       20
       20
       +
           Eq,

     

       21
       21
       +
           jacquard_derive::IntoStatic,

     

       22
       22
       +
           bon::Builder

     

       23
       23
       +
       )]

     

       24
       24
       +
       #[serde(rename_all = "camelCase")]

     

       25
       25
       +
       pub struct Song<'a> {

     

       26
       26
       +
           /// The album of the song.

     

       27
       27
       +
           #[serde(borrow)]

     

       28
       28
       +
           #[builder(into)]

     

       29
       29
       +
           pub album: jacquard_common::CowStr<'a>,

     

       30
       30
       +
           /// The album art of the song.

     

       31
       31
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       32
       32
       +
           #[builder(into)]

     

       33
       33
       +
           #[serde(borrow)]

     

       34
       34
       +
           pub album_art: Option<jacquard_common::types::blob::Blob<'a>>,

     

       35
       35
       +
           /// The album artist of the song.

     

       36
       36
       +
           #[serde(borrow)]

     

       37
       37
       +
           #[builder(into)]

     

       38
       38
       +
           pub album_artist: jacquard_common::CowStr<'a>,

     

       39
       39
       +
           /// The Apple Music link of the song.

     

       40
       40
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
       +
           #[builder(into)]

     

       42
       42
       +
           #[serde(borrow)]

     

       43
       43
       +
           pub apple_music_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       44
       44
       +
           /// The artist of the song.

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           #[builder(into)]

     

       47
       47
       +
           pub artist: jacquard_common::CowStr<'a>,

     

       48
       48
       +
           /// The composer of the song.

     

       49
       49
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       50
       50
       +
           #[builder(into)]

     

       51
       51
       +
           #[serde(borrow)]

     

       52
       52
       +
           pub composer: Option<jacquard_common::CowStr<'a>>,

     

       53
       53
       +
           /// The copyright message of the song.

     

       54
       54
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       55
       55
       +
           #[builder(into)]

     

       56
       56
       +
           #[serde(borrow)]

     

       57
       57
       +
           pub copyright_message: Option<jacquard_common::CowStr<'a>>,

     

       58
       58
       +
           /// The date when the song was created.

     

       59
       59
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       60
       60
       +
           /// The disc number of the song in the album.

     

       61
       61
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       62
       62
       +
           #[builder(into)]

     

       63
       63
       +
           pub disc_number: Option<i64>,

     

       64
       64
       +
           /// The duration of the song in seconds.

     

       65
       65
       +
           pub duration: i64,

     

       66
       66
       +
           /// The genre of the song.

     

       67
       67
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       68
       68
       +
           #[builder(into)]

     

       69
       69
       +
           #[serde(borrow)]

     

       70
       70
       +
           pub genre: Option<jacquard_common::CowStr<'a>>,

     

       71
       71
       +
           /// The label of the song.

     

       72
       72
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       73
       73
       +
           #[builder(into)]

     

       74
       74
       +
           #[serde(borrow)]

     

       75
       75
       +
           pub label: Option<jacquard_common::CowStr<'a>>,

     

       76
       76
       +
           /// The lyrics of the song.

     

       77
       77
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       78
       78
       +
           #[builder(into)]

     

       79
       79
       +
           #[serde(borrow)]

     

       80
       80
       +
           pub lyrics: Option<jacquard_common::CowStr<'a>>,

     

       81
       81
       +
           /// The MusicBrainz ID of the song.

     

       82
       82
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       83
       83
       +
           #[builder(into)]

     

       84
       84
       +
           #[serde(borrow)]

     

       85
       85
       +
           pub mbid: Option<jacquard_common::CowStr<'a>>,

     

       86
       86
       +
           /// The release date of the song.

     

       87
       87
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       88
       88
       +
           #[builder(into)]

     

       89
       89
       +
           pub release_date: Option<jacquard_common::types::string::Datetime>,

     

       90
       90
       +
           /// The Spotify link of the song.

     

       91
       91
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       92
       92
       +
           #[builder(into)]

     

       93
       93
       +
           #[serde(borrow)]

     

       94
       94
       +
           pub spotify_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       95
       95
       +
           /// The tags of the song.

     

       96
       96
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       97
       97
       +
           #[builder(into)]

     

       98
       98
       +
           #[serde(borrow)]

     

       99
       99
       +
           pub tags: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       100
       100
       +
           /// The Tidal link of the song.

     

       101
       101
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       102
       102
       +
           #[builder(into)]

     

       103
       103
       +
           #[serde(borrow)]

     

       104
       104
       +
           pub tidal_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       105
       105
       +
           /// The title of the song.

     

       106
       106
       +
           #[serde(borrow)]

     

       107
       107
       +
           #[builder(into)]

     

       108
       108
       +
           pub title: jacquard_common::CowStr<'a>,

     

       109
       109
       +
           /// The track number of the song in the album.

     

       110
       110
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       111
       111
       +
           #[builder(into)]

     

       112
       112
       +
           pub track_number: Option<i64>,

     

       113
       113
       +
           /// Informations about the song

     

       114
       114
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       115
       115
       +
           #[builder(into)]

     

       116
       116
       +
           #[serde(borrow)]

     

       117
       117
       +
           pub wiki: Option<jacquard_common::CowStr<'a>>,

     

       118
       118
       +
           /// The year the song was released.

     

       119
       119
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       120
       120
       +
           #[builder(into)]

     

       121
       121
       +
           pub year: Option<i64>,

     

       122
       122
       +
           /// The YouTube link of the song.

     

       123
       123
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       124
       124
       +
           #[builder(into)]

     

       125
       125
       +
           #[serde(borrow)]

     

       126
       126
       +
           pub youtube_link: Option<jacquard_common::types::string::Uri<'a>>,

     

       127
       127
       +
       }

     

       128
       128
       +
       

     

       129
       129
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       130
       130
       +
       #[derive(

     

       131
       131
       +
           serde::Serialize,

     

       132
       132
       +
           serde::Deserialize,

     

       133
       133
       +
           Debug,

     

       134
       134
       +
           Clone,

     

       135
       135
       +
           PartialEq,

     

       136
       136
       +
           Eq,

     

       137
       137
       +
           jacquard_derive::IntoStatic

     

       138
       138
       +
       )]

     

       139
       139
       +
       #[serde(rename_all = "camelCase")]

     

       140
       140
       +
       pub struct SongGetRecordOutput<'a> {

     

       141
       141
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       142
       142
       +
           #[serde(borrow)]

     

       143
       143
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       144
       144
       +
           #[serde(borrow)]

     

       145
       145
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       146
       146
       +
           #[serde(borrow)]

     

       147
       147
       +
           pub value: Song<'a>,

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       /// Marker type for deserializing records from this collection.

     

       151
       151
       +
       pub struct SongRecord;

     

       152
       152
       +
       impl jacquard_common::xrpc::XrpcResp for SongRecord {

     

       153
       153
       +
           const NSID: &'static str = "app.rocksky.song";

     

       154
       154
       +
           const ENCODING: &'static str = "application/json";

     

       155
       155
       +
           type Output<'de> = SongGetRecordOutput<'de>;

     

       156
       156
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       impl jacquard_common::types::collection::Collection for Song<'_> {

     

       160
       160
       +
           const NSID: &'static str = "app.rocksky.song";

     

       161
       161
       +
           type Record = SongRecord;

     

       162
       162
       +
       }

     

       163
       163
       +
       

     

       164
       164
       +
       impl From<SongGetRecordOutput<'_>> for Song<'_> {

     

       165
       165
       +
           fn from(output: SongGetRecordOutput<'_>) -> Self {

     

       166
       166
       +
               use jacquard_common::IntoStatic;

     

       167
       167
       +
               output.value.into_static()

     

       168
       168
       +
           }

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       #[jacquard_derive::lexicon]

     

       172
       172
       +
       #[derive(

     

       173
       173
       +
           serde::Serialize,

     

       174
       174
       +
           serde::Deserialize,

     

       175
       175
       +
           Debug,

     

       176
       176
       +
           Clone,

     

       177
       177
       +
           PartialEq,

     

       178
       178
       +
           Eq,

     

       179
       179
       +
           jacquard_derive::IntoStatic,

     

       180
       180
       +
           Default

     

       181
       181
       +
       )]

     

       182
       182
       +
       #[serde(rename_all = "camelCase")]

     

       183
       183
       +
       pub struct SongViewBasic<'a> {

     

       184
       184
       +
           /// The album of the song.

     

       185
       185
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       186
       186
       +
           #[serde(borrow)]

     

       187
       187
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       188
       188
       +
           /// The URL of the album art image.

     

       189
       189
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       190
       190
       +
           #[serde(borrow)]

     

       191
       191
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       192
       192
       +
           /// The artist of the album the song belongs to.

     

       193
       193
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       194
       194
       +
           #[serde(borrow)]

     

       195
       195
       +
           pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       196
       196
       +
           /// The URI of the album the song belongs to.

     

       197
       197
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       198
       198
       +
           #[serde(borrow)]

     

       199
       199
       +
           pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       200
       200
       +
           /// The artist of the song.

     

       201
       201
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       202
       202
       +
           #[serde(borrow)]

     

       203
       203
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       204
       204
       +
           /// The URI of the artist of the song.

     

       205
       205
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       206
       206
       +
           #[serde(borrow)]

     

       207
       207
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       208
       208
       +
           /// The timestamp when the song was created.

     

       209
       209
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       210
       210
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       211
       211
       +
           /// The disc number of the song in the album.

     

       212
       212
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       213
       213
       +
           pub disc_number: std::option::Option<i64>,

     

       214
       214
       +
           /// The duration of the song in milliseconds.

     

       215
       215
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       216
       216
       +
           pub duration: std::option::Option<i64>,

     

       217
       217
       +
           /// The unique identifier of the song.

     

       218
       218
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       219
       219
       +
           #[serde(borrow)]

     

       220
       220
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       221
       221
       +
           /// The number of times the song has been played.

     

       222
       222
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       223
       223
       +
           pub play_count: std::option::Option<i64>,

     

       224
       224
       +
           /// The SHA256 hash of the song.

     

       225
       225
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       226
       226
       +
           #[serde(borrow)]

     

       227
       227
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       228
       228
       +
           /// The title of the song.

     

       229
       229
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       230
       230
       +
           #[serde(borrow)]

     

       231
       231
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       232
       232
       +
           /// The track number of the song in the album.

     

       233
       233
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       234
       234
       +
           pub track_number: std::option::Option<i64>,

     

       235
       235
       +
           /// The number of unique listeners who have played the song.

     

       236
       236
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       237
       237
       +
           pub unique_listeners: std::option::Option<i64>,

     

       238
       238
       +
           /// The URI of the song.

     

       239
       239
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       240
       240
       +
           #[serde(borrow)]

     

       241
       241
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       242
       242
       +
       }

     

       243
       243
       +
       

     

       244
       244
       +
       #[jacquard_derive::lexicon]

     

       245
       245
       +
       #[derive(

     

       246
       246
       +
           serde::Serialize,

     

       247
       247
       +
           serde::Deserialize,

     

       248
       248
       +
           Debug,

     

       249
       249
       +
           Clone,

     

       250
       250
       +
           PartialEq,

     

       251
       251
       +
           Eq,

     

       252
       252
       +
           jacquard_derive::IntoStatic,

     

       253
       253
       +
           Default

     

       254
       254
       +
       )]

     

       255
       255
       +
       #[serde(rename_all = "camelCase")]

     

       256
       256
       +
       pub struct SongViewDetailed<'a> {

     

       257
       257
       +
           /// The album of the song.

     

       258
       258
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       259
       259
       +
           #[serde(borrow)]

     

       260
       260
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       261
       261
       +
           /// The URL of the album art image.

     

       262
       262
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       263
       263
       +
           #[serde(borrow)]

     

       264
       264
       +
           pub album_art: std::option::Option<jacquard_common::types::string::Uri<'a>>,

     

       265
       265
       +
           /// The artist of the album the song belongs to.

     

       266
       266
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       267
       267
       +
           #[serde(borrow)]

     

       268
       268
       +
           pub album_artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       269
       269
       +
           /// The URI of the album the song belongs to.

     

       270
       270
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       271
       271
       +
           #[serde(borrow)]

     

       272
       272
       +
           pub album_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       273
       273
       +
           /// The artist of the song.

     

       274
       274
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       275
       275
       +
           #[serde(borrow)]

     

       276
       276
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       277
       277
       +
           /// The URI of the artist of the song.

     

       278
       278
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       279
       279
       +
           #[serde(borrow)]

     

       280
       280
       +
           pub artist_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       281
       281
       +
           /// The timestamp when the song was created.

     

       282
       282
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       283
       283
       +
           pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,

     

       284
       284
       +
           /// The disc number of the song in the album.

     

       285
       285
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       286
       286
       +
           pub disc_number: std::option::Option<i64>,

     

       287
       287
       +
           /// The duration of the song in milliseconds.

     

       288
       288
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       289
       289
       +
           pub duration: std::option::Option<i64>,

     

       290
       290
       +
           /// The unique identifier of the song.

     

       291
       291
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       292
       292
       +
           #[serde(borrow)]

     

       293
       293
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       294
       294
       +
           /// The number of times the song has been played.

     

       295
       295
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       296
       296
       +
           pub play_count: std::option::Option<i64>,

     

       297
       297
       +
           /// The SHA256 hash of the song.

     

       298
       298
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       299
       299
       +
           #[serde(borrow)]

     

       300
       300
       +
           pub sha256: std::option::Option<jacquard_common::CowStr<'a>>,

     

       301
       301
       +
           /// The title of the song.

     

       302
       302
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       303
       303
       +
           #[serde(borrow)]

     

       304
       304
       +
           pub title: std::option::Option<jacquard_common::CowStr<'a>>,

     

       305
       305
       +
           /// The track number of the song in the album.

     

       306
       306
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       307
       307
       +
           pub track_number: std::option::Option<i64>,

     

       308
       308
       +
           /// The number of unique listeners who have played the song.

     

       309
       309
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       310
       310
       +
           pub unique_listeners: std::option::Option<i64>,

     

       311
       311
       +
           /// The URI of the song.

     

       312
       312
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       313
       313
       +
           #[serde(borrow)]

     

       314
       314
       +
           pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       315
       315
       +
       }

+67

crates/jacquard-api/src/app_rocksky/spotify/get_currently_playing.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.getCurrentlyPlaying

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetCurrentlyPlaying<'a> {

     

       21
       21
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       22
       22
       +
           #[serde(borrow)]

     

       23
       23
       +
           pub actor: std::option::Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       #[jacquard_derive::lexicon]

     

       27
       27
       +
       #[derive(

     

       28
       28
       +
           serde::Serialize,

     

       29
       29
       +
           serde::Deserialize,

     

       30
       30
       +
           Debug,

     

       31
       31
       +
           Clone,

     

       32
       32
       +
           PartialEq,

     

       33
       33
       +
           Eq,

     

       34
       34
       +
           jacquard_derive::IntoStatic

     

       35
       35
       +
       )]

     

       36
       36
       +
       #[serde(rename_all = "camelCase")]

     

       37
       37
       +
       pub struct GetCurrentlyPlayingOutput<'a> {

     

       38
       38
       +
           #[serde(flatten)]

     

       39
       39
       +
           #[serde(borrow)]

     

       40
       40
       +
           pub value: crate::app_rocksky::player::CurrentlyPlayingViewDetailed<'a>,

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       ///Response type for

     

       44
       44
       +
       ///app.rocksky.spotify.getCurrentlyPlaying

     

       45
       45
       +
       pub struct GetCurrentlyPlayingResponse;

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcResp for GetCurrentlyPlayingResponse {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.spotify.getCurrentlyPlaying";

     

       48
       48
       +
           const ENCODING: &'static str = "application/json";

     

       49
       49
       +
           type Output<'de> = GetCurrentlyPlayingOutput<'de>;

     

       50
       50
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetCurrentlyPlaying<'a> {

     

       54
       54
       +
           const NSID: &'static str = "app.rocksky.spotify.getCurrentlyPlaying";

     

       55
       55
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       56
       56
       +
           type Response = GetCurrentlyPlayingResponse;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       ///Endpoint type for

     

       60
       60
       +
       ///app.rocksky.spotify.getCurrentlyPlaying

     

       61
       61
       +
       pub struct GetCurrentlyPlayingRequest;

     

       62
       62
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetCurrentlyPlayingRequest {

     

       63
       63
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.getCurrentlyPlaying";

     

       64
       64
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       65
       65
       +
           type Request<'de> = GetCurrentlyPlaying<'de>;

     

       66
       66
       +
           type Response = GetCurrentlyPlayingResponse;

     

       67
       67
       +
       }

+48

crates/jacquard-api/src/app_rocksky/spotify/next.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.next

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Next;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.spotify.next

     

       22
       22
       +
       pub struct NextResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for NextResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.spotify.next";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Next {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.spotify.next";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = NextResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.spotify.next

     

       40
       40
       +
       pub struct NextRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for NextRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.next";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Next;

     

       47
       47
       +
           type Response = NextResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/spotify/pause.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.pause

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Pause;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.spotify.pause

     

       22
       22
       +
       pub struct PauseResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PauseResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.spotify.pause";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Pause {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.spotify.pause";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PauseResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.spotify.pause

     

       40
       40
       +
       pub struct PauseRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PauseRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.pause";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Pause;

     

       47
       47
       +
           type Response = PauseResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/spotify/play.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.play

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Play;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.spotify.play

     

       22
       22
       +
       pub struct PlayResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PlayResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.spotify.play";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Play {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.spotify.play";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PlayResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.spotify.play

     

       40
       40
       +
       pub struct PlayRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PlayRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.play";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Play;

     

       47
       47
       +
           type Response = PlayResponse;

     

       48
       48
       +
       }

+48

crates/jacquard-api/src/app_rocksky/spotify/previous.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.previous

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// XRPC request marker type

     

       9
       9
       +
       #[derive(

     

       10
       10
       +
           Debug,

     

       11
       11
       +
           Clone,

     

       12
       12
       +
           Copy,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           serde::Serialize,

     

       16
       16
       +
           serde::Deserialize,

     

       17
       17
       +
           jacquard_derive::IntoStatic

     

       18
       18
       +
       )]

     

       19
       19
       +
       pub struct Previous;

     

       20
       20
       +
       ///Response type for

     

       21
       21
       +
       ///app.rocksky.spotify.previous

     

       22
       22
       +
       pub struct PreviousResponse;

     

       23
       23
       +
       impl jacquard_common::xrpc::XrpcResp for PreviousResponse {

     

       24
       24
       +
           const NSID: &'static str = "app.rocksky.spotify.previous";

     

       25
       25
       +
           const ENCODING: &'static str = "application/json";

     

       26
       26
       +
           type Output<'de> = ();

     

       27
       27
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       impl jacquard_common::xrpc::XrpcRequest for Previous {

     

       31
       31
       +
           const NSID: &'static str = "app.rocksky.spotify.previous";

     

       32
       32
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       33
       33
       +
               "application/json",

     

       34
       34
       +
           );

     

       35
       35
       +
           type Response = PreviousResponse;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       ///Endpoint type for

     

       39
       39
       +
       ///app.rocksky.spotify.previous

     

       40
       40
       +
       pub struct PreviousRequest;

     

       41
       41
       +
       impl jacquard_common::xrpc::XrpcEndpoint for PreviousRequest {

     

       42
       42
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.previous";

     

       43
       43
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       44
       44
       +
               "application/json",

     

       45
       45
       +
           );

     

       46
       46
       +
           type Request<'de> = Previous;

     

       47
       47
       +
           type Response = PreviousResponse;

     

       48
       48
       +
       }

+64

crates/jacquard-api/src/app_rocksky/spotify/seek.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.seek

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct SeekParams {

     

       21
       21
       +
           pub position: i64,

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       /// XRPC request marker type

     

       25
       25
       +
       #[derive(

     

       26
       26
       +
           Debug,

     

       27
       27
       +
           Clone,

     

       28
       28
       +
           Copy,

     

       29
       29
       +
           PartialEq,

     

       30
       30
       +
           Eq,

     

       31
       31
       +
           serde::Serialize,

     

       32
       32
       +
           serde::Deserialize,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       pub struct Seek;

     

       36
       36
       +
       ///Response type for

     

       37
       37
       +
       ///app.rocksky.spotify.seek

     

       38
       38
       +
       pub struct SeekResponse;

     

       39
       39
       +
       impl jacquard_common::xrpc::XrpcResp for SeekResponse {

     

       40
       40
       +
           const NSID: &'static str = "app.rocksky.spotify.seek";

     

       41
       41
       +
           const ENCODING: &'static str = "application/json";

     

       42
       42
       +
           type Output<'de> = ();

     

       43
       43
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       impl jacquard_common::xrpc::XrpcRequest for Seek {

     

       47
       47
       +
           const NSID: &'static str = "app.rocksky.spotify.seek";

     

       48
       48
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       49
       49
       +
               "application/json",

     

       50
       50
       +
           );

     

       51
       51
       +
           type Response = SeekResponse;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       ///Endpoint type for

     

       55
       55
       +
       ///app.rocksky.spotify.seek

     

       56
       56
       +
       pub struct SeekRequest;

     

       57
       57
       +
       impl jacquard_common::xrpc::XrpcEndpoint for SeekRequest {

     

       58
       58
       +
           const PATH: &'static str = "/xrpc/app.rocksky.spotify.seek";

     

       59
       59
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(

     

       60
       60
       +
               "application/json",

     

       61
       61
       +
           );

     

       62
       62
       +
           type Request<'de> = Seek;

     

       63
       63
       +
           type Response = SeekResponse;

     

       64
       64
       +
       }

+51

crates/jacquard-api/src/app_rocksky/spotify.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.spotify.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_currently_playing;

     

       9
       9
       +
       pub mod next;

     

       10
       10
       +
       pub mod pause;

     

       11
       11
       +
       pub mod play;

     

       12
       12
       +
       pub mod previous;

     

       13
       13
       +
       pub mod seek;

     

       14
       14
       +
       

     

       15
       15
       +
       #[jacquard_derive::lexicon]

     

       16
       16
       +
       #[derive(

     

       17
       17
       +
           serde::Serialize,

     

       18
       18
       +
           serde::Deserialize,

     

       19
       19
       +
           Debug,

     

       20
       20
       +
           Clone,

     

       21
       21
       +
           PartialEq,

     

       22
       22
       +
           Eq,

     

       23
       23
       +
           jacquard_derive::IntoStatic,

     

       24
       24
       +
           Default

     

       25
       25
       +
       )]

     

       26
       26
       +
       #[serde(rename_all = "camelCase")]

     

       27
       27
       +
       pub struct SpotifyTrackView<'a> {

     

       28
       28
       +
           /// The name of the album.

     

       29
       29
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       30
       30
       +
           #[serde(borrow)]

     

       31
       31
       +
           pub album: std::option::Option<jacquard_common::CowStr<'a>>,

     

       32
       32
       +
           /// The name of the artist.

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           #[serde(borrow)]

     

       35
       35
       +
           pub artist: std::option::Option<jacquard_common::CowStr<'a>>,

     

       36
       36
       +
           /// The duration of the track in milliseconds.

     

       37
       37
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       38
       38
       +
           pub duration: std::option::Option<i64>,

     

       39
       39
       +
           /// The unique identifier of the Spotify track.

     

       40
       40
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       41
       41
       +
           #[serde(borrow)]

     

       42
       42
       +
           pub id: std::option::Option<jacquard_common::CowStr<'a>>,

     

       43
       43
       +
           /// The name of the track.

     

       44
       44
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       45
       45
       +
           #[serde(borrow)]

     

       46
       46
       +
           pub name: std::option::Option<jacquard_common::CowStr<'a>>,

     

       47
       47
       +
           /// A URL to a preview of the track.

     

       48
       48
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       49
       49
       +
           #[serde(borrow)]

     

       50
       50
       +
           pub preview_url: std::option::Option<jacquard_common::CowStr<'a>>,

     

       51
       51
       +
       }

+66

crates/jacquard-api/src/app_rocksky/stats/get_stats.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.stats.getStats

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(

     

       9
       9
       +
           serde::Serialize,

     

       10
       10
       +
           serde::Deserialize,

     

       11
       11
       +
           Debug,

     

       12
       12
       +
           Clone,

     

       13
       13
       +
           PartialEq,

     

       14
       14
       +
           Eq,

     

       15
       15
       +
           bon::Builder,

     

       16
       16
       +
           jacquard_derive::IntoStatic

     

       17
       17
       +
       )]

     

       18
       18
       +
       #[builder(start_fn = new)]

     

       19
       19
       +
       #[serde(rename_all = "camelCase")]

     

       20
       20
       +
       pub struct GetStats<'a> {

     

       21
       21
       +
           #[serde(borrow)]

     

       22
       22
       +
           pub did: jacquard_common::types::ident::AtIdentifier<'a>,

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       #[jacquard_derive::lexicon]

     

       26
       26
       +
       #[derive(

     

       27
       27
       +
           serde::Serialize,

     

       28
       28
       +
           serde::Deserialize,

     

       29
       29
       +
           Debug,

     

       30
       30
       +
           Clone,

     

       31
       31
       +
           PartialEq,

     

       32
       32
       +
           Eq,

     

       33
       33
       +
           jacquard_derive::IntoStatic

     

       34
       34
       +
       )]

     

       35
       35
       +
       #[serde(rename_all = "camelCase")]

     

       36
       36
       +
       pub struct GetStatsOutput<'a> {

     

       37
       37
       +
           #[serde(flatten)]

     

       38
       38
       +
           #[serde(borrow)]

     

       39
       39
       +
           pub value: crate::app_rocksky::stats::StatsView<'a>,

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       ///Response type for

     

       43
       43
       +
       ///app.rocksky.stats.getStats

     

       44
       44
       +
       pub struct GetStatsResponse;

     

       45
       45
       +
       impl jacquard_common::xrpc::XrpcResp for GetStatsResponse {

     

       46
       46
       +
           const NSID: &'static str = "app.rocksky.stats.getStats";

     

       47
       47
       +
           const ENCODING: &'static str = "application/json";

     

       48
       48
       +
           type Output<'de> = GetStatsOutput<'de>;

     

       49
       49
       +
           type Err<'de> = jacquard_common::xrpc::GenericError<'de>;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       impl<'a> jacquard_common::xrpc::XrpcRequest for GetStats<'a> {

     

       53
       53
       +
           const NSID: &'static str = "app.rocksky.stats.getStats";

     

       54
       54
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       55
       55
       +
           type Response = GetStatsResponse;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       ///Endpoint type for

     

       59
       59
       +
       ///app.rocksky.stats.getStats

     

       60
       60
       +
       pub struct GetStatsRequest;

     

       61
       61
       +
       impl jacquard_common::xrpc::XrpcEndpoint for GetStatsRequest {

     

       62
       62
       +
           const PATH: &'static str = "/xrpc/app.rocksky.stats.getStats";

     

       63
       63
       +
           const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;

     

       64
       64
       +
           type Request<'de> = GetStats<'de>;

     

       65
       65
       +
           type Response = GetStatsResponse;

     

       66
       66
       +
       }

+38

crates/jacquard-api/src/app_rocksky/stats.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: app.rocksky.stats.defs

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       pub mod get_stats;

     

       9
       9
       +
       

     

       10
       10
       +
       #[jacquard_derive::lexicon]

     

       11
       11
       +
       #[derive(

     

       12
       12
       +
           serde::Serialize,

     

       13
       13
       +
           serde::Deserialize,

     

       14
       14
       +
           Debug,

     

       15
       15
       +
           Clone,

     

       16
       16
       +
           PartialEq,

     

       17
       17
       +
           Eq,

     

       18
       18
       +
           jacquard_derive::IntoStatic,

     

       19
       19
       +
           Default

     

       20
       20
       +
       )]

     

       21
       21
       +
       #[serde(rename_all = "camelCase")]

     

       22
       22
       +
       pub struct StatsView<'a> {

     

       23
       23
       +
           /// The total number of unique albums scrobbled.

     

       24
       24
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       25
       25
       +
           pub albums: std::option::Option<i64>,

     

       26
       26
       +
           /// The total number of unique artists scrobbled.

     

       27
       27
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       28
       28
       +
           pub artists: std::option::Option<i64>,

     

       29
       29
       +
           /// The total number of tracks marked as loved.

     

       30
       30
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       31
       31
       +
           pub loved_tracks: std::option::Option<i64>,

     

       32
       32
       +
           /// The total number of scrobbles.

     

       33
       33
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       34
       34
       +
           pub scrobbles: std::option::Option<i64>,

     

       35
       35
       +
           /// The total number of unique tracks scrobbled.

     

       36
       36
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       37
       37
       +
           pub tracks: std::option::Option<i64>,

     

       38
       38
       +
       }

+22

crates/jacquard-api/src/app_rocksky 2.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod actor;

     

       7
       7
       +
       pub mod album;

     

       8
       8
       +
       pub mod apikey;

     

       9
       9
       +
       pub mod artist;

     

       10
       10
       +
       pub mod charts;

     

       11
       11
       +
       pub mod dropbox;

     

       12
       12
       +
       pub mod feed;

     

       13
       13
       +
       pub mod googledrive;

     

       14
       14
       +
       pub mod like;

     

       15
       15
       +
       pub mod player;

     

       16
       16
       +
       pub mod playlist;

     

       17
       17
       +
       pub mod radio;

     

       18
       18
       +
       pub mod scrobble;

     

       19
       19
       +
       pub mod shout;

     

       20
       20
       +
       pub mod song;

     

       21
       21
       +
       pub mod spotify;

     

       22
       22
       +
       pub mod stats;

+22

crates/jacquard-api/src/app_rocksky.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod actor;

     

       7
       7
       +
       pub mod album;

     

       8
       8
       +
       pub mod apikey;

     

       9
       9
       +
       pub mod artist;

     

       10
       10
       +
       pub mod charts;

     

       11
       11
       +
       pub mod dropbox;

     

       12
       12
       +
       pub mod feed;

     

       13
       13
       +
       pub mod googledrive;

     

       14
       14
       +
       pub mod like;

     

       15
       15
       +
       pub mod player;

     

       16
       16
       +
       pub mod playlist;

     

       17
       17
       +
       pub mod radio;

     

       18
       18
       +
       pub mod scrobble;

     

       19
       19
       +
       pub mod shout;

     

       20
       20
       +
       pub mod song;

     

       21
       21
       +
       pub mod spotify;

     

       22
       22
       +
       pub mod stats;

crates/jacquard-api/src/lib.rs

···

       12
       12
        
       #[cfg(feature = "app_ocho")]

     

       13
       13
        
       pub mod app_ocho;

     

       14
       14
        
       

     

       15
       15
       +
       #[cfg(feature = "app_rocksky")]

     

       16
       16
       +
       pub mod app_rocksky;

     

       17
       17
       +
       

     

       15
       18
        
       #[cfg(feature = "beauty_cybernetic")]

     

       16
       19
        
       pub mod beauty_cybernetic;

     

       17
       20
        
       

     
···

       86
       89
        
       

     

       87
       90
        
       #[cfg(feature = "net_aftertheinter")]

     

       88
       91
        
       pub mod net_aftertheinter;

     

       92
       92
       +
       

     

       93
       93
       +
       #[cfg(feature = "net_altq")]

     

       94
       94
       +
       pub mod net_altq;

     

       89
       95
        
       

     

       90
       96
        
       #[cfg(feature = "net_anisota")]

     

       91
       97
        
       pub mod net_anisota;

+135

crates/jacquard-api/src/net_altq/aqfile.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // Lexicon: net.altq.aqfile

     

       4
       4
       +
       //

     

       5
       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       7
       +
       

     

       8
       8
       +
       /// Cryptographic checksum for integrity verification.

     

       9
       9
       +
       #[jacquard_derive::lexicon]

     

       10
       10
       +
       #[derive(

     

       11
       11
       +
           serde::Serialize,

     

       12
       12
       +
           serde::Deserialize,

     

       13
       13
       +
           Debug,

     

       14
       14
       +
           Clone,

     

       15
       15
       +
           PartialEq,

     

       16
       16
       +
           Eq,

     

       17
       17
       +
           jacquard_derive::IntoStatic,

     

       18
       18
       +
           Default

     

       19
       19
       +
       )]

     

       20
       20
       +
       #[serde(rename_all = "camelCase")]

     

       21
       21
       +
       pub struct Checksum<'a> {

     

       22
       22
       +
           /// Hash algorithm name.

     

       23
       23
       +
           #[serde(borrow)]

     

       24
       24
       +
           pub algo: jacquard_common::CowStr<'a>,

     

       25
       25
       +
           /// Hex or base64 encoded digest produced by the algorithm.

     

       26
       26
       +
           #[serde(borrow)]

     

       27
       27
       +
           pub hash: jacquard_common::CowStr<'a>,

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       /// File metadata describing the uploaded blob.

     

       31
       31
       +
       #[jacquard_derive::lexicon]

     

       32
       32
       +
       #[derive(

     

       33
       33
       +
           serde::Serialize,

     

       34
       34
       +
           serde::Deserialize,

     

       35
       35
       +
           Debug,

     

       36
       36
       +
           Clone,

     

       37
       37
       +
           PartialEq,

     

       38
       38
       +
           Eq,

     

       39
       39
       +
           jacquard_derive::IntoStatic,

     

       40
       40
       +
           bon::Builder

     

       41
       41
       +
       )]

     

       42
       42
       +
       #[serde(rename_all = "camelCase")]

     

       43
       43
       +
       pub struct File<'a> {

     

       44
       44
       +
           /// MIME type, e.g. 'video/mp4'.

     

       45
       45
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       46
       46
       +
           #[builder(into)]

     

       47
       47
       +
           #[serde(borrow)]

     

       48
       48
       +
           pub mime_type: Option<jacquard_common::CowStr<'a>>,

     

       49
       49
       +
           /// Client-side last-modified timestamp.

     

       50
       50
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       51
       51
       +
           #[builder(into)]

     

       52
       52
       +
           pub modified_at: Option<jacquard_common::types::string::Datetime>,

     

       53
       53
       +
           /// User-visible filename.

     

       54
       54
       +
           #[serde(borrow)]

     

       55
       55
       +
           #[builder(into)]

     

       56
       56
       +
           pub name: jacquard_common::CowStr<'a>,

     

       57
       57
       +
           /// File size in bytes.

     

       58
       58
       +
           pub size: i64,

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       /// A record representing an uploaded file blob with metadata.

     

       62
       62
       +
       #[jacquard_derive::lexicon]

     

       63
       63
       +
       #[derive(

     

       64
       64
       +
           serde::Serialize,

     

       65
       65
       +
           serde::Deserialize,

     

       66
       66
       +
           Debug,

     

       67
       67
       +
           Clone,

     

       68
       68
       +
           PartialEq,

     

       69
       69
       +
           Eq,

     

       70
       70
       +
           jacquard_derive::IntoStatic,

     

       71
       71
       +
           bon::Builder

     

       72
       72
       +
       )]

     

       73
       73
       +
       #[serde(rename_all = "camelCase")]

     

       74
       74
       +
       pub struct Aqfile<'a> {

     

       75
       75
       +
           /// Handle or DID of the account to attribute this upload to.

     

       76
       76
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       77
       77
       +
           #[builder(into)]

     

       78
       78
       +
           #[serde(borrow)]

     

       79
       79
       +
           pub attribution: Option<jacquard_common::types::ident::AtIdentifier<'a>>,

     

       80
       80
       +
           /// The uploaded blob reference. Note: Individual PDS instances may enforce lower size limits.

     

       81
       81
       +
           #[serde(borrow)]

     

       82
       82
       +
           pub blob: jacquard_common::types::blob::Blob<'a>,

     

       83
       83
       +
           /// Optional cryptographic checksum for integrity verification.

     

       84
       84
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       85
       85
       +
           #[builder(into)]

     

       86
       86
       +
           #[serde(borrow)]

     

       87
       87
       +
           pub checksum: Option<crate::net_altq::aqfile::Checksum<'a>>,

     

       88
       88
       +
           /// Timestamp when this record was created.

     

       89
       89
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       90
       90
       +
           /// Metadata about the file.

     

       91
       91
       +
           #[serde(borrow)]

     

       92
       92
       +
           pub file: crate::net_altq::aqfile::File<'a>,

     

       93
       93
       +
       }

     

       94
       94
       +
       

     

       95
       95
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       96
       96
       +
       #[derive(

     

       97
       97
       +
           serde::Serialize,

     

       98
       98
       +
           serde::Deserialize,

     

       99
       99
       +
           Debug,

     

       100
       100
       +
           Clone,

     

       101
       101
       +
           PartialEq,

     

       102
       102
       +
           Eq,

     

       103
       103
       +
           jacquard_derive::IntoStatic

     

       104
       104
       +
       )]

     

       105
       105
       +
       #[serde(rename_all = "camelCase")]

     

       106
       106
       +
       pub struct AqfileGetRecordOutput<'a> {

     

       107
       107
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       108
       108
       +
           #[serde(borrow)]

     

       109
       109
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       110
       110
       +
           #[serde(borrow)]

     

       111
       111
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       112
       112
       +
           #[serde(borrow)]

     

       113
       113
       +
           pub value: Aqfile<'a>,

     

       114
       114
       +
       }

     

       115
       115
       +
       

     

       116
       116
       +
       /// Marker type for deserializing records from this collection.

     

       117
       117
       +
       pub struct AqfileRecord;

     

       118
       118
       +
       impl jacquard_common::xrpc::XrpcResp for AqfileRecord {

     

       119
       119
       +
           const NSID: &'static str = "net.altq.aqfile";

     

       120
       120
       +
           const ENCODING: &'static str = "application/json";

     

       121
       121
       +
           type Output<'de> = AqfileGetRecordOutput<'de>;

     

       122
       122
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       123
       123
       +
       }

     

       124
       124
       +
       

     

       125
       125
       +
       impl jacquard_common::types::collection::Collection for Aqfile<'_> {

     

       126
       126
       +
           const NSID: &'static str = "net.altq.aqfile";

     

       127
       127
       +
           type Record = AqfileRecord;

     

       128
       128
       +
       }

     

       129
       129
       +
       

     

       130
       130
       +
       impl From<AqfileGetRecordOutput<'_>> for Aqfile<'_> {

     

       131
       131
       +
           fn from(output: AqfileGetRecordOutput<'_>) -> Self {

     

       132
       132
       +
               use jacquard_common::IntoStatic;

     

       133
       133
       +
               output.value.into_static()

     

       134
       134
       +
           }

     

       135
       135
       +
       }

crates/jacquard-api/src/net_altq 2.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod aqfile;

crates/jacquard-api/src/net_altq.rs

···

       1
       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       2
       +
       //

     

       3
       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       5
       +
       

     

       6
       6
       +
       pub mod aqfile;

lexicons.kdl

···

       94
       94
        
           repo "https://github.com/Gregoor/skylights"

     

       95
       95
        
           pattern "**/*.json"

     

       96
       96
        
       }

     

       97
       97
       +
       

     

       98
       98
       +
       source "rocksky" type="git" priority=50 {

     

       99
       99
       +
           repo "https://github.com/tsirysndr/rocksky-lexicons/"

     

       100
       100
       +
           pattern "lexicons/**/*.json"

     

       101
       101
       +
       }

Compare changes