Rockbox open source high quality audio player as a Music Player Daemon
mpris
rockbox
mpd
libadwaita
audio
rust
zig
deno
Add Saved and Smart Playlist UI and Services
+5986
-60
+17
macos/Rockbox/Models/Core/Playlist.swift
+17
macos/Rockbox/Models/Core/Playlist.swift
···
14
14
let description: String?
15
15
let tracks: [Song]
16
16
}
17
+
18
+
struct SavedPlaylist: Identifiable {
19
+
let id: String
20
+
let name: String
21
+
let description: String?
22
+
let image: String?
23
+
let folderID: String?
24
+
let trackCount: Int64
25
+
}
26
+
27
+
struct SmartPlaylist: Identifiable {
28
+
let id: String
29
+
let name: String
30
+
let description: String?
31
+
let image: String?
32
+
let isSystem: Bool
33
+
}
+4
-2
macos/Rockbox/Models/Enums/SidebarItem.swift
+4
-2
macos/Rockbox/Models/Enums/SidebarItem.swift
···
12
12
case artists = "Artists"
13
13
case songs = "Songs"
14
14
case likes = "Likes"
15
+
case playlists = "Playlists"
15
16
case files = "Files"
16
-
17
+
17
18
var id: String { rawValue }
18
-
19
+
19
20
var icon: String {
20
21
switch self {
21
22
case .albums: return "square.stack"
22
23
case .artists: return "music.mic"
23
24
case .songs: return "music.note"
24
25
case .likes: return "heart"
26
+
case .playlists: return "music.note.list"
25
27
case .files: return "folder"
26
28
}
27
29
}
+7
macos/Rockbox/Services/AlbumService.swift
+7
macos/Rockbox/Services/AlbumService.swift
···
48
48
}
49
49
}
50
50
51
+
func fetchAlbumTracks(albumID: String, host: String = "127.0.0.1", port: Int = 6061) async throws
52
+
-> [Rockbox_V1alpha1_Track]
53
+
{
54
+
let album = try await fetchAlbum(id: albumID, host: host, port: port)
55
+
return album.tracks
56
+
}
57
+
51
58
func likeAlbum(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
52
59
try await withGRPCClient(
53
60
transport: .http2NIOPosix(
+175
macos/Rockbox/Services/SavedPlaylistService.swift
+175
macos/Rockbox/Services/SavedPlaylistService.swift
···
1
+
//
2
+
// SavedPlaylistService.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import GRPCCore
7
+
import GRPCNIOTransportHTTP2
8
+
9
+
func fetchSavedPlaylists(
10
+
folderID: String? = nil,
11
+
host: String = "127.0.0.1",
12
+
port: Int = 6061
13
+
) async throws -> [Rockbox_V1alpha1_SavedPlaylist] {
14
+
try await withGRPCClient(
15
+
transport: .http2NIOPosix(
16
+
target: .dns(host: host, port: port),
17
+
transportSecurity: .plaintext
18
+
)
19
+
) { grpcClient in
20
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
21
+
var req = Rockbox_V1alpha1_GetSavedPlaylistsRequest()
22
+
if let fid = folderID { req.folderID = fid }
23
+
let res = try await service.getSavedPlaylists(req)
24
+
return res.playlists
25
+
}
26
+
}
27
+
28
+
func fetchSavedPlaylist(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws
29
+
-> Rockbox_V1alpha1_SavedPlaylist?
30
+
{
31
+
try await withGRPCClient(
32
+
transport: .http2NIOPosix(
33
+
target: .dns(host: host, port: port),
34
+
transportSecurity: .plaintext
35
+
)
36
+
) { grpcClient in
37
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
38
+
var req = Rockbox_V1alpha1_GetSavedPlaylistRequest()
39
+
req.id = id
40
+
let res = try await service.getSavedPlaylist(req)
41
+
return res.hasPlaylist ? res.playlist : nil
42
+
}
43
+
}
44
+
45
+
func createSavedPlaylist(
46
+
name: String,
47
+
description: String? = nil,
48
+
trackIDs: [String] = [],
49
+
host: String = "127.0.0.1",
50
+
port: Int = 6061
51
+
) async throws -> Rockbox_V1alpha1_SavedPlaylist {
52
+
try await withGRPCClient(
53
+
transport: .http2NIOPosix(
54
+
target: .dns(host: host, port: port),
55
+
transportSecurity: .plaintext
56
+
)
57
+
) { grpcClient in
58
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
59
+
var req = Rockbox_V1alpha1_CreateSavedPlaylistRequest()
60
+
req.name = name
61
+
if let desc = description { req.description_p = desc }
62
+
req.trackIDs = trackIDs
63
+
let res = try await service.createSavedPlaylist(req)
64
+
return res.playlist
65
+
}
66
+
}
67
+
68
+
func updateSavedPlaylist(
69
+
id: String,
70
+
name: String,
71
+
description: String? = nil,
72
+
host: String = "127.0.0.1",
73
+
port: Int = 6061
74
+
) async throws {
75
+
try await withGRPCClient(
76
+
transport: .http2NIOPosix(
77
+
target: .dns(host: host, port: port),
78
+
transportSecurity: .plaintext
79
+
)
80
+
) { grpcClient in
81
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
82
+
var req = Rockbox_V1alpha1_UpdateSavedPlaylistRequest()
83
+
req.id = id
84
+
req.name = name
85
+
if let desc = description { req.description_p = desc }
86
+
let _ = try await service.updateSavedPlaylist(req)
87
+
}
88
+
}
89
+
90
+
func deleteSavedPlaylist(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
91
+
try await withGRPCClient(
92
+
transport: .http2NIOPosix(
93
+
target: .dns(host: host, port: port),
94
+
transportSecurity: .plaintext
95
+
)
96
+
) { grpcClient in
97
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
98
+
var req = Rockbox_V1alpha1_DeleteSavedPlaylistRequest()
99
+
req.id = id
100
+
let _ = try await service.deleteSavedPlaylist(req)
101
+
}
102
+
}
103
+
104
+
func fetchSavedPlaylistTracks(
105
+
playlistID: String,
106
+
host: String = "127.0.0.1",
107
+
port: Int = 6061
108
+
) async throws -> [String] {
109
+
try await withGRPCClient(
110
+
transport: .http2NIOPosix(
111
+
target: .dns(host: host, port: port),
112
+
transportSecurity: .plaintext
113
+
)
114
+
) { grpcClient in
115
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
116
+
var req = Rockbox_V1alpha1_GetSavedPlaylistTracksRequest()
117
+
req.playlistID = playlistID
118
+
let res = try await service.getSavedPlaylistTracks(req)
119
+
return res.trackIDs
120
+
}
121
+
}
122
+
123
+
func addTracksToSavedPlaylist(
124
+
playlistID: String,
125
+
trackIDs: [String],
126
+
host: String = "127.0.0.1",
127
+
port: Int = 6061
128
+
) async throws {
129
+
try await withGRPCClient(
130
+
transport: .http2NIOPosix(
131
+
target: .dns(host: host, port: port),
132
+
transportSecurity: .plaintext
133
+
)
134
+
) { grpcClient in
135
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
136
+
var req = Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest()
137
+
req.playlistID = playlistID
138
+
req.trackIDs = trackIDs
139
+
let _ = try await service.addTracksToSavedPlaylist(req)
140
+
}
141
+
}
142
+
143
+
func removeTrackFromSavedPlaylist(
144
+
playlistID: String,
145
+
trackID: String,
146
+
host: String = "127.0.0.1",
147
+
port: Int = 6061
148
+
) async throws {
149
+
try await withGRPCClient(
150
+
transport: .http2NIOPosix(
151
+
target: .dns(host: host, port: port),
152
+
transportSecurity: .plaintext
153
+
)
154
+
) { grpcClient in
155
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
156
+
var req = Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest()
157
+
req.playlistID = playlistID
158
+
req.trackID = trackID
159
+
let _ = try await service.removeTrackFromSavedPlaylist(req)
160
+
}
161
+
}
162
+
163
+
func playSavedPlaylist(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
164
+
try await withGRPCClient(
165
+
transport: .http2NIOPosix(
166
+
target: .dns(host: host, port: port),
167
+
transportSecurity: .plaintext
168
+
)
169
+
) { grpcClient in
170
+
let service = Rockbox_V1alpha1_SavedPlaylistService.Client(wrapping: grpcClient)
171
+
var req = Rockbox_V1alpha1_PlaySavedPlaylistRequest()
172
+
req.playlistID = id
173
+
let _ = try await service.playSavedPlaylist(req)
174
+
}
175
+
}
+84
macos/Rockbox/Services/SmartPlaylistService.swift
+84
macos/Rockbox/Services/SmartPlaylistService.swift
···
1
+
//
2
+
// SmartPlaylistService.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import GRPCCore
7
+
import GRPCNIOTransportHTTP2
8
+
9
+
func fetchSmartPlaylists(host: String = "127.0.0.1", port: Int = 6061) async throws
10
+
-> [Rockbox_V1alpha1_SmartPlaylist]
11
+
{
12
+
try await withGRPCClient(
13
+
transport: .http2NIOPosix(
14
+
target: .dns(host: host, port: port),
15
+
transportSecurity: .plaintext
16
+
)
17
+
) { grpcClient in
18
+
let service = Rockbox_V1alpha1_SmartPlaylistService.Client(wrapping: grpcClient)
19
+
let req = Rockbox_V1alpha1_GetSmartPlaylistsRequest()
20
+
let res = try await service.getSmartPlaylists(req)
21
+
return res.playlists
22
+
}
23
+
}
24
+
25
+
func fetchSmartPlaylistTracks(
26
+
id: String,
27
+
host: String = "127.0.0.1",
28
+
port: Int = 6061
29
+
) async throws -> [String] {
30
+
try await withGRPCClient(
31
+
transport: .http2NIOPosix(
32
+
target: .dns(host: host, port: port),
33
+
transportSecurity: .plaintext
34
+
)
35
+
) { grpcClient in
36
+
let service = Rockbox_V1alpha1_SmartPlaylistService.Client(wrapping: grpcClient)
37
+
var req = Rockbox_V1alpha1_GetSmartPlaylistTracksRequest()
38
+
req.id = id
39
+
let res = try await service.getSmartPlaylistTracks(req)
40
+
return res.trackIDs
41
+
}
42
+
}
43
+
44
+
func playSmartPlaylist(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
45
+
try await withGRPCClient(
46
+
transport: .http2NIOPosix(
47
+
target: .dns(host: host, port: port),
48
+
transportSecurity: .plaintext
49
+
)
50
+
) { grpcClient in
51
+
let service = Rockbox_V1alpha1_SmartPlaylistService.Client(wrapping: grpcClient)
52
+
var req = Rockbox_V1alpha1_PlaySmartPlaylistRequest()
53
+
req.id = id
54
+
let _ = try await service.playSmartPlaylist(req)
55
+
}
56
+
}
57
+
58
+
func deleteSmartPlaylist(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
59
+
try await withGRPCClient(
60
+
transport: .http2NIOPosix(
61
+
target: .dns(host: host, port: port),
62
+
transportSecurity: .plaintext
63
+
)
64
+
) { grpcClient in
65
+
let service = Rockbox_V1alpha1_SmartPlaylistService.Client(wrapping: grpcClient)
66
+
var req = Rockbox_V1alpha1_DeleteSmartPlaylistRequest()
67
+
req.id = id
68
+
let _ = try await service.deleteSmartPlaylist(req)
69
+
}
70
+
}
71
+
72
+
func recordTrackPlayed(trackID: String, host: String = "127.0.0.1", port: Int = 6061) async throws {
73
+
try await withGRPCClient(
74
+
transport: .http2NIOPosix(
75
+
target: .dns(host: host, port: port),
76
+
transportSecurity: .plaintext
77
+
)
78
+
) { grpcClient in
79
+
let service = Rockbox_V1alpha1_SmartPlaylistService.Client(wrapping: grpcClient)
80
+
var req = Rockbox_V1alpha1_RecordTrackPlayedRequest()
81
+
req.trackID = trackID
82
+
let _ = try await service.recordTrackPlayed(req)
83
+
}
84
+
}
+17
macos/Rockbox/Services/TrackService.swift
+17
macos/Rockbox/Services/TrackService.swift
···
9
9
import GRPCCore
10
10
import GRPCNIOTransportHTTP2
11
11
12
+
func fetchTrack(id: String, host: String = "127.0.0.1", port: Int = 6061) async throws
13
+
-> Rockbox_V1alpha1_Track
14
+
{
15
+
try await withGRPCClient(
16
+
transport: .http2NIOPosix(
17
+
target: .dns(host: host, port: port),
18
+
transportSecurity: .plaintext
19
+
)
20
+
) { grpcClient in
21
+
let library = Rockbox_V1alpha1_LibraryService.Client(wrapping: grpcClient)
22
+
var req = Rockbox_V1alpha1_GetTrackRequest()
23
+
req.id = id
24
+
let res = try await library.getTrack(req)
25
+
return res.track
26
+
}
27
+
}
28
+
12
29
func fetchTracks(host: String = "127.0.0.1", port: Int = 6061) async throws
13
30
-> [Rockbox_V1alpha1_Track]
14
31
{
+974
macos/Rockbox/Services/rockbox/v1alpha1/saved_playlist.grpc.swift
+974
macos/Rockbox/Services/rockbox/v1alpha1/saved_playlist.grpc.swift
···
1
+
// DO NOT EDIT.
2
+
// swift-format-ignore-file
3
+
// swiftlint:disable all
4
+
//
5
+
// Generated by the gRPC Swift generator plugin for the protocol buffer compiler.
6
+
// Source: rockbox/v1alpha1/saved_playlist.proto
7
+
//
8
+
// For information on using the generated types, please see the documentation:
9
+
// https://github.com/grpc/grpc-swift
10
+
11
+
import GRPCCore
12
+
import GRPCProtobuf
13
+
14
+
// MARK: - rockbox.v1alpha1.SavedPlaylistService
15
+
16
+
/// Namespace containing generated types for the "rockbox.v1alpha1.SavedPlaylistService" service.
17
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
18
+
internal enum Rockbox_V1alpha1_SavedPlaylistService: Sendable {
19
+
/// Service descriptor for the "rockbox.v1alpha1.SavedPlaylistService" service.
20
+
internal static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService")
21
+
/// Namespace for method metadata.
22
+
internal enum Method: Sendable {
23
+
/// Namespace for "CreatePlaylistFolder" metadata.
24
+
internal enum CreatePlaylistFolder: Sendable {
25
+
/// Request type for "CreatePlaylistFolder".
26
+
internal typealias Input = Rockbox_V1alpha1_CreatePlaylistFolderRequest
27
+
/// Response type for "CreatePlaylistFolder".
28
+
internal typealias Output = Rockbox_V1alpha1_CreatePlaylistFolderResponse
29
+
/// Descriptor for "CreatePlaylistFolder".
30
+
internal static let descriptor = GRPCCore.MethodDescriptor(
31
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
32
+
method: "CreatePlaylistFolder"
33
+
)
34
+
}
35
+
/// Namespace for "GetPlaylistFolders" metadata.
36
+
internal enum GetPlaylistFolders: Sendable {
37
+
/// Request type for "GetPlaylistFolders".
38
+
internal typealias Input = Rockbox_V1alpha1_GetPlaylistFoldersRequest
39
+
/// Response type for "GetPlaylistFolders".
40
+
internal typealias Output = Rockbox_V1alpha1_GetPlaylistFoldersResponse
41
+
/// Descriptor for "GetPlaylistFolders".
42
+
internal static let descriptor = GRPCCore.MethodDescriptor(
43
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
44
+
method: "GetPlaylistFolders"
45
+
)
46
+
}
47
+
/// Namespace for "DeletePlaylistFolder" metadata.
48
+
internal enum DeletePlaylistFolder: Sendable {
49
+
/// Request type for "DeletePlaylistFolder".
50
+
internal typealias Input = Rockbox_V1alpha1_DeletePlaylistFolderRequest
51
+
/// Response type for "DeletePlaylistFolder".
52
+
internal typealias Output = Rockbox_V1alpha1_DeletePlaylistFolderResponse
53
+
/// Descriptor for "DeletePlaylistFolder".
54
+
internal static let descriptor = GRPCCore.MethodDescriptor(
55
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
56
+
method: "DeletePlaylistFolder"
57
+
)
58
+
}
59
+
/// Namespace for "GetSavedPlaylists" metadata.
60
+
internal enum GetSavedPlaylists: Sendable {
61
+
/// Request type for "GetSavedPlaylists".
62
+
internal typealias Input = Rockbox_V1alpha1_GetSavedPlaylistsRequest
63
+
/// Response type for "GetSavedPlaylists".
64
+
internal typealias Output = Rockbox_V1alpha1_GetSavedPlaylistsResponse
65
+
/// Descriptor for "GetSavedPlaylists".
66
+
internal static let descriptor = GRPCCore.MethodDescriptor(
67
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
68
+
method: "GetSavedPlaylists"
69
+
)
70
+
}
71
+
/// Namespace for "GetSavedPlaylist" metadata.
72
+
internal enum GetSavedPlaylist: Sendable {
73
+
/// Request type for "GetSavedPlaylist".
74
+
internal typealias Input = Rockbox_V1alpha1_GetSavedPlaylistRequest
75
+
/// Response type for "GetSavedPlaylist".
76
+
internal typealias Output = Rockbox_V1alpha1_GetSavedPlaylistResponse
77
+
/// Descriptor for "GetSavedPlaylist".
78
+
internal static let descriptor = GRPCCore.MethodDescriptor(
79
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
80
+
method: "GetSavedPlaylist"
81
+
)
82
+
}
83
+
/// Namespace for "CreateSavedPlaylist" metadata.
84
+
internal enum CreateSavedPlaylist: Sendable {
85
+
/// Request type for "CreateSavedPlaylist".
86
+
internal typealias Input = Rockbox_V1alpha1_CreateSavedPlaylistRequest
87
+
/// Response type for "CreateSavedPlaylist".
88
+
internal typealias Output = Rockbox_V1alpha1_CreateSavedPlaylistResponse
89
+
/// Descriptor for "CreateSavedPlaylist".
90
+
internal static let descriptor = GRPCCore.MethodDescriptor(
91
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
92
+
method: "CreateSavedPlaylist"
93
+
)
94
+
}
95
+
/// Namespace for "UpdateSavedPlaylist" metadata.
96
+
internal enum UpdateSavedPlaylist: Sendable {
97
+
/// Request type for "UpdateSavedPlaylist".
98
+
internal typealias Input = Rockbox_V1alpha1_UpdateSavedPlaylistRequest
99
+
/// Response type for "UpdateSavedPlaylist".
100
+
internal typealias Output = Rockbox_V1alpha1_UpdateSavedPlaylistResponse
101
+
/// Descriptor for "UpdateSavedPlaylist".
102
+
internal static let descriptor = GRPCCore.MethodDescriptor(
103
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
104
+
method: "UpdateSavedPlaylist"
105
+
)
106
+
}
107
+
/// Namespace for "DeleteSavedPlaylist" metadata.
108
+
internal enum DeleteSavedPlaylist: Sendable {
109
+
/// Request type for "DeleteSavedPlaylist".
110
+
internal typealias Input = Rockbox_V1alpha1_DeleteSavedPlaylistRequest
111
+
/// Response type for "DeleteSavedPlaylist".
112
+
internal typealias Output = Rockbox_V1alpha1_DeleteSavedPlaylistResponse
113
+
/// Descriptor for "DeleteSavedPlaylist".
114
+
internal static let descriptor = GRPCCore.MethodDescriptor(
115
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
116
+
method: "DeleteSavedPlaylist"
117
+
)
118
+
}
119
+
/// Namespace for "GetSavedPlaylistTracks" metadata.
120
+
internal enum GetSavedPlaylistTracks: Sendable {
121
+
/// Request type for "GetSavedPlaylistTracks".
122
+
internal typealias Input = Rockbox_V1alpha1_GetSavedPlaylistTracksRequest
123
+
/// Response type for "GetSavedPlaylistTracks".
124
+
internal typealias Output = Rockbox_V1alpha1_GetSavedPlaylistTracksResponse
125
+
/// Descriptor for "GetSavedPlaylistTracks".
126
+
internal static let descriptor = GRPCCore.MethodDescriptor(
127
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
128
+
method: "GetSavedPlaylistTracks"
129
+
)
130
+
}
131
+
/// Namespace for "AddTracksToSavedPlaylist" metadata.
132
+
internal enum AddTracksToSavedPlaylist: Sendable {
133
+
/// Request type for "AddTracksToSavedPlaylist".
134
+
internal typealias Input = Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest
135
+
/// Response type for "AddTracksToSavedPlaylist".
136
+
internal typealias Output = Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse
137
+
/// Descriptor for "AddTracksToSavedPlaylist".
138
+
internal static let descriptor = GRPCCore.MethodDescriptor(
139
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
140
+
method: "AddTracksToSavedPlaylist"
141
+
)
142
+
}
143
+
/// Namespace for "RemoveTrackFromSavedPlaylist" metadata.
144
+
internal enum RemoveTrackFromSavedPlaylist: Sendable {
145
+
/// Request type for "RemoveTrackFromSavedPlaylist".
146
+
internal typealias Input = Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest
147
+
/// Response type for "RemoveTrackFromSavedPlaylist".
148
+
internal typealias Output = Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse
149
+
/// Descriptor for "RemoveTrackFromSavedPlaylist".
150
+
internal static let descriptor = GRPCCore.MethodDescriptor(
151
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
152
+
method: "RemoveTrackFromSavedPlaylist"
153
+
)
154
+
}
155
+
/// Namespace for "PlaySavedPlaylist" metadata.
156
+
internal enum PlaySavedPlaylist: Sendable {
157
+
/// Request type for "PlaySavedPlaylist".
158
+
internal typealias Input = Rockbox_V1alpha1_PlaySavedPlaylistRequest
159
+
/// Response type for "PlaySavedPlaylist".
160
+
internal typealias Output = Rockbox_V1alpha1_PlaySavedPlaylistResponse
161
+
/// Descriptor for "PlaySavedPlaylist".
162
+
internal static let descriptor = GRPCCore.MethodDescriptor(
163
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService"),
164
+
method: "PlaySavedPlaylist"
165
+
)
166
+
}
167
+
/// Descriptors for all methods in the "rockbox.v1alpha1.SavedPlaylistService" service.
168
+
internal static let descriptors: [GRPCCore.MethodDescriptor] = [
169
+
CreatePlaylistFolder.descriptor,
170
+
GetPlaylistFolders.descriptor,
171
+
DeletePlaylistFolder.descriptor,
172
+
GetSavedPlaylists.descriptor,
173
+
GetSavedPlaylist.descriptor,
174
+
CreateSavedPlaylist.descriptor,
175
+
UpdateSavedPlaylist.descriptor,
176
+
DeleteSavedPlaylist.descriptor,
177
+
GetSavedPlaylistTracks.descriptor,
178
+
AddTracksToSavedPlaylist.descriptor,
179
+
RemoveTrackFromSavedPlaylist.descriptor,
180
+
PlaySavedPlaylist.descriptor
181
+
]
182
+
}
183
+
}
184
+
185
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
186
+
extension GRPCCore.ServiceDescriptor {
187
+
/// Service descriptor for the "rockbox.v1alpha1.SavedPlaylistService" service.
188
+
internal static let rockbox_v1Alpha1_SavedPlaylistService = GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SavedPlaylistService")
189
+
}
190
+
191
+
// MARK: rockbox.v1alpha1.SavedPlaylistService (client)
192
+
193
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
194
+
extension Rockbox_V1alpha1_SavedPlaylistService {
195
+
/// Generated client protocol for the "rockbox.v1alpha1.SavedPlaylistService" service.
196
+
///
197
+
/// You don't need to implement this protocol directly, use the generated
198
+
/// implementation, ``Client``.
199
+
internal protocol ClientProtocol: Sendable {
200
+
/// Call the "CreatePlaylistFolder" method.
201
+
func createPlaylistFolder<Result>(
202
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreatePlaylistFolderRequest>,
203
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreatePlaylistFolderRequest>,
204
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreatePlaylistFolderResponse>,
205
+
options: GRPCCore.CallOptions,
206
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreatePlaylistFolderResponse>) async throws -> Result
207
+
) async throws -> Result where Result: Sendable
208
+
209
+
/// Call the "GetPlaylistFolders" method.
210
+
func getPlaylistFolders<Result>(
211
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetPlaylistFoldersRequest>,
212
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetPlaylistFoldersRequest>,
213
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetPlaylistFoldersResponse>,
214
+
options: GRPCCore.CallOptions,
215
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetPlaylistFoldersResponse>) async throws -> Result
216
+
) async throws -> Result where Result: Sendable
217
+
218
+
/// Call the "DeletePlaylistFolder" method.
219
+
func deletePlaylistFolder<Result>(
220
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeletePlaylistFolderRequest>,
221
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeletePlaylistFolderRequest>,
222
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeletePlaylistFolderResponse>,
223
+
options: GRPCCore.CallOptions,
224
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeletePlaylistFolderResponse>) async throws -> Result
225
+
) async throws -> Result where Result: Sendable
226
+
227
+
/// Call the "GetSavedPlaylists" method.
228
+
func getSavedPlaylists<Result>(
229
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistsRequest>,
230
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistsRequest>,
231
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistsResponse>,
232
+
options: GRPCCore.CallOptions,
233
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistsResponse>) async throws -> Result
234
+
) async throws -> Result where Result: Sendable
235
+
236
+
/// Call the "GetSavedPlaylist" method.
237
+
func getSavedPlaylist<Result>(
238
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistRequest>,
239
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistRequest>,
240
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistResponse>,
241
+
options: GRPCCore.CallOptions,
242
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistResponse>) async throws -> Result
243
+
) async throws -> Result where Result: Sendable
244
+
245
+
/// Call the "CreateSavedPlaylist" method.
246
+
func createSavedPlaylist<Result>(
247
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSavedPlaylistRequest>,
248
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreateSavedPlaylistRequest>,
249
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreateSavedPlaylistResponse>,
250
+
options: GRPCCore.CallOptions,
251
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSavedPlaylistResponse>) async throws -> Result
252
+
) async throws -> Result where Result: Sendable
253
+
254
+
/// Call the "UpdateSavedPlaylist" method.
255
+
func updateSavedPlaylist<Result>(
256
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>,
257
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>,
258
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>,
259
+
options: GRPCCore.CallOptions,
260
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>) async throws -> Result
261
+
) async throws -> Result where Result: Sendable
262
+
263
+
/// Call the "DeleteSavedPlaylist" method.
264
+
func deleteSavedPlaylist<Result>(
265
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>,
266
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>,
267
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>,
268
+
options: GRPCCore.CallOptions,
269
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>) async throws -> Result
270
+
) async throws -> Result where Result: Sendable
271
+
272
+
/// Call the "GetSavedPlaylistTracks" method.
273
+
func getSavedPlaylistTracks<Result>(
274
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>,
275
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>,
276
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>,
277
+
options: GRPCCore.CallOptions,
278
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>) async throws -> Result
279
+
) async throws -> Result where Result: Sendable
280
+
281
+
/// Call the "AddTracksToSavedPlaylist" method.
282
+
func addTracksToSavedPlaylist<Result>(
283
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>,
284
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>,
285
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>,
286
+
options: GRPCCore.CallOptions,
287
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>) async throws -> Result
288
+
) async throws -> Result where Result: Sendable
289
+
290
+
/// Call the "RemoveTrackFromSavedPlaylist" method.
291
+
func removeTrackFromSavedPlaylist<Result>(
292
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>,
293
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>,
294
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>,
295
+
options: GRPCCore.CallOptions,
296
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>) async throws -> Result
297
+
) async throws -> Result where Result: Sendable
298
+
299
+
/// Call the "PlaySavedPlaylist" method.
300
+
func playSavedPlaylist<Result>(
301
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySavedPlaylistRequest>,
302
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_PlaySavedPlaylistRequest>,
303
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_PlaySavedPlaylistResponse>,
304
+
options: GRPCCore.CallOptions,
305
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySavedPlaylistResponse>) async throws -> Result
306
+
) async throws -> Result where Result: Sendable
307
+
}
308
+
309
+
/// Generated client for the "rockbox.v1alpha1.SavedPlaylistService" service.
310
+
internal struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
311
+
private let client: GRPCCore.GRPCClient<Transport>
312
+
313
+
/// Creates a new client wrapping the provided `GRPCCore.GRPCClient`.
314
+
internal init(wrapping client: GRPCCore.GRPCClient<Transport>) {
315
+
self.client = client
316
+
}
317
+
318
+
internal func createPlaylistFolder<Result>(
319
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreatePlaylistFolderRequest>,
320
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreatePlaylistFolderRequest>,
321
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreatePlaylistFolderResponse>,
322
+
options: GRPCCore.CallOptions = .defaults,
323
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreatePlaylistFolderResponse>) async throws -> Result = { response in
324
+
try response.message
325
+
}
326
+
) async throws -> Result where Result: Sendable {
327
+
try await self.client.unary(
328
+
request: request,
329
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.CreatePlaylistFolder.descriptor,
330
+
serializer: serializer,
331
+
deserializer: deserializer,
332
+
options: options,
333
+
onResponse: handleResponse
334
+
)
335
+
}
336
+
337
+
internal func getPlaylistFolders<Result>(
338
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetPlaylistFoldersRequest>,
339
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetPlaylistFoldersRequest>,
340
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetPlaylistFoldersResponse>,
341
+
options: GRPCCore.CallOptions = .defaults,
342
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetPlaylistFoldersResponse>) async throws -> Result = { response in
343
+
try response.message
344
+
}
345
+
) async throws -> Result where Result: Sendable {
346
+
try await self.client.unary(
347
+
request: request,
348
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.GetPlaylistFolders.descriptor,
349
+
serializer: serializer,
350
+
deserializer: deserializer,
351
+
options: options,
352
+
onResponse: handleResponse
353
+
)
354
+
}
355
+
356
+
internal func deletePlaylistFolder<Result>(
357
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeletePlaylistFolderRequest>,
358
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeletePlaylistFolderRequest>,
359
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeletePlaylistFolderResponse>,
360
+
options: GRPCCore.CallOptions = .defaults,
361
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeletePlaylistFolderResponse>) async throws -> Result = { response in
362
+
try response.message
363
+
}
364
+
) async throws -> Result where Result: Sendable {
365
+
try await self.client.unary(
366
+
request: request,
367
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.DeletePlaylistFolder.descriptor,
368
+
serializer: serializer,
369
+
deserializer: deserializer,
370
+
options: options,
371
+
onResponse: handleResponse
372
+
)
373
+
}
374
+
375
+
internal func getSavedPlaylists<Result>(
376
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistsRequest>,
377
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistsRequest>,
378
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistsResponse>,
379
+
options: GRPCCore.CallOptions = .defaults,
380
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistsResponse>) async throws -> Result = { response in
381
+
try response.message
382
+
}
383
+
) async throws -> Result where Result: Sendable {
384
+
try await self.client.unary(
385
+
request: request,
386
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.GetSavedPlaylists.descriptor,
387
+
serializer: serializer,
388
+
deserializer: deserializer,
389
+
options: options,
390
+
onResponse: handleResponse
391
+
)
392
+
}
393
+
394
+
internal func getSavedPlaylist<Result>(
395
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistRequest>,
396
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistRequest>,
397
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistResponse>,
398
+
options: GRPCCore.CallOptions = .defaults,
399
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistResponse>) async throws -> Result = { response in
400
+
try response.message
401
+
}
402
+
) async throws -> Result where Result: Sendable {
403
+
try await self.client.unary(
404
+
request: request,
405
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.GetSavedPlaylist.descriptor,
406
+
serializer: serializer,
407
+
deserializer: deserializer,
408
+
options: options,
409
+
onResponse: handleResponse
410
+
)
411
+
}
412
+
413
+
internal func createSavedPlaylist<Result>(
414
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSavedPlaylistRequest>,
415
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreateSavedPlaylistRequest>,
416
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreateSavedPlaylistResponse>,
417
+
options: GRPCCore.CallOptions = .defaults,
418
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSavedPlaylistResponse>) async throws -> Result = { response in
419
+
try response.message
420
+
}
421
+
) async throws -> Result where Result: Sendable {
422
+
try await self.client.unary(
423
+
request: request,
424
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.CreateSavedPlaylist.descriptor,
425
+
serializer: serializer,
426
+
deserializer: deserializer,
427
+
options: options,
428
+
onResponse: handleResponse
429
+
)
430
+
}
431
+
432
+
internal func updateSavedPlaylist<Result>(
433
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>,
434
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>,
435
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>,
436
+
options: GRPCCore.CallOptions = .defaults,
437
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>) async throws -> Result = { response in
438
+
try response.message
439
+
}
440
+
) async throws -> Result where Result: Sendable {
441
+
try await self.client.unary(
442
+
request: request,
443
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.UpdateSavedPlaylist.descriptor,
444
+
serializer: serializer,
445
+
deserializer: deserializer,
446
+
options: options,
447
+
onResponse: handleResponse
448
+
)
449
+
}
450
+
451
+
internal func deleteSavedPlaylist<Result>(
452
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>,
453
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>,
454
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>,
455
+
options: GRPCCore.CallOptions = .defaults,
456
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>) async throws -> Result = { response in
457
+
try response.message
458
+
}
459
+
) async throws -> Result where Result: Sendable {
460
+
try await self.client.unary(
461
+
request: request,
462
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.DeleteSavedPlaylist.descriptor,
463
+
serializer: serializer,
464
+
deserializer: deserializer,
465
+
options: options,
466
+
onResponse: handleResponse
467
+
)
468
+
}
469
+
470
+
internal func getSavedPlaylistTracks<Result>(
471
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>,
472
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>,
473
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>,
474
+
options: GRPCCore.CallOptions = .defaults,
475
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>) async throws -> Result = { response in
476
+
try response.message
477
+
}
478
+
) async throws -> Result where Result: Sendable {
479
+
try await self.client.unary(
480
+
request: request,
481
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.GetSavedPlaylistTracks.descriptor,
482
+
serializer: serializer,
483
+
deserializer: deserializer,
484
+
options: options,
485
+
onResponse: handleResponse
486
+
)
487
+
}
488
+
489
+
internal func addTracksToSavedPlaylist<Result>(
490
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>,
491
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>,
492
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>,
493
+
options: GRPCCore.CallOptions = .defaults,
494
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>) async throws -> Result = { response in
495
+
try response.message
496
+
}
497
+
) async throws -> Result where Result: Sendable {
498
+
try await self.client.unary(
499
+
request: request,
500
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.AddTracksToSavedPlaylist.descriptor,
501
+
serializer: serializer,
502
+
deserializer: deserializer,
503
+
options: options,
504
+
onResponse: handleResponse
505
+
)
506
+
}
507
+
508
+
internal func removeTrackFromSavedPlaylist<Result>(
509
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>,
510
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>,
511
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>,
512
+
options: GRPCCore.CallOptions = .defaults,
513
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>) async throws -> Result = { response in
514
+
try response.message
515
+
}
516
+
) async throws -> Result where Result: Sendable {
517
+
try await self.client.unary(
518
+
request: request,
519
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.RemoveTrackFromSavedPlaylist.descriptor,
520
+
serializer: serializer,
521
+
deserializer: deserializer,
522
+
options: options,
523
+
onResponse: handleResponse
524
+
)
525
+
}
526
+
527
+
internal func playSavedPlaylist<Result>(
528
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySavedPlaylistRequest>,
529
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_PlaySavedPlaylistRequest>,
530
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_PlaySavedPlaylistResponse>,
531
+
options: GRPCCore.CallOptions = .defaults,
532
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySavedPlaylistResponse>) async throws -> Result = { response in
533
+
try response.message
534
+
}
535
+
) async throws -> Result where Result: Sendable {
536
+
try await self.client.unary(
537
+
request: request,
538
+
descriptor: Rockbox_V1alpha1_SavedPlaylistService.Method.PlaySavedPlaylist.descriptor,
539
+
serializer: serializer,
540
+
deserializer: deserializer,
541
+
options: options,
542
+
onResponse: handleResponse
543
+
)
544
+
}
545
+
}
546
+
}
547
+
548
+
// Helpers providing default arguments to 'ClientProtocol' methods.
549
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
550
+
extension Rockbox_V1alpha1_SavedPlaylistService.ClientProtocol {
551
+
internal func createPlaylistFolder<Result>(
552
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreatePlaylistFolderRequest>,
553
+
options: GRPCCore.CallOptions = .defaults,
554
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreatePlaylistFolderResponse>) async throws -> Result = { response in
555
+
try response.message
556
+
}
557
+
) async throws -> Result where Result: Sendable {
558
+
try await self.createPlaylistFolder(
559
+
request: request,
560
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_CreatePlaylistFolderRequest>(),
561
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_CreatePlaylistFolderResponse>(),
562
+
options: options,
563
+
onResponse: handleResponse
564
+
)
565
+
}
566
+
567
+
internal func getPlaylistFolders<Result>(
568
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetPlaylistFoldersRequest>,
569
+
options: GRPCCore.CallOptions = .defaults,
570
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetPlaylistFoldersResponse>) async throws -> Result = { response in
571
+
try response.message
572
+
}
573
+
) async throws -> Result where Result: Sendable {
574
+
try await self.getPlaylistFolders(
575
+
request: request,
576
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetPlaylistFoldersRequest>(),
577
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetPlaylistFoldersResponse>(),
578
+
options: options,
579
+
onResponse: handleResponse
580
+
)
581
+
}
582
+
583
+
internal func deletePlaylistFolder<Result>(
584
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeletePlaylistFolderRequest>,
585
+
options: GRPCCore.CallOptions = .defaults,
586
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeletePlaylistFolderResponse>) async throws -> Result = { response in
587
+
try response.message
588
+
}
589
+
) async throws -> Result where Result: Sendable {
590
+
try await self.deletePlaylistFolder(
591
+
request: request,
592
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_DeletePlaylistFolderRequest>(),
593
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_DeletePlaylistFolderResponse>(),
594
+
options: options,
595
+
onResponse: handleResponse
596
+
)
597
+
}
598
+
599
+
internal func getSavedPlaylists<Result>(
600
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistsRequest>,
601
+
options: GRPCCore.CallOptions = .defaults,
602
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistsResponse>) async throws -> Result = { response in
603
+
try response.message
604
+
}
605
+
) async throws -> Result where Result: Sendable {
606
+
try await self.getSavedPlaylists(
607
+
request: request,
608
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSavedPlaylistsRequest>(),
609
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSavedPlaylistsResponse>(),
610
+
options: options,
611
+
onResponse: handleResponse
612
+
)
613
+
}
614
+
615
+
internal func getSavedPlaylist<Result>(
616
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistRequest>,
617
+
options: GRPCCore.CallOptions = .defaults,
618
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistResponse>) async throws -> Result = { response in
619
+
try response.message
620
+
}
621
+
) async throws -> Result where Result: Sendable {
622
+
try await self.getSavedPlaylist(
623
+
request: request,
624
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSavedPlaylistRequest>(),
625
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSavedPlaylistResponse>(),
626
+
options: options,
627
+
onResponse: handleResponse
628
+
)
629
+
}
630
+
631
+
internal func createSavedPlaylist<Result>(
632
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSavedPlaylistRequest>,
633
+
options: GRPCCore.CallOptions = .defaults,
634
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSavedPlaylistResponse>) async throws -> Result = { response in
635
+
try response.message
636
+
}
637
+
) async throws -> Result where Result: Sendable {
638
+
try await self.createSavedPlaylist(
639
+
request: request,
640
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_CreateSavedPlaylistRequest>(),
641
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_CreateSavedPlaylistResponse>(),
642
+
options: options,
643
+
onResponse: handleResponse
644
+
)
645
+
}
646
+
647
+
internal func updateSavedPlaylist<Result>(
648
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>,
649
+
options: GRPCCore.CallOptions = .defaults,
650
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>) async throws -> Result = { response in
651
+
try response.message
652
+
}
653
+
) async throws -> Result where Result: Sendable {
654
+
try await self.updateSavedPlaylist(
655
+
request: request,
656
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>(),
657
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>(),
658
+
options: options,
659
+
onResponse: handleResponse
660
+
)
661
+
}
662
+
663
+
internal func deleteSavedPlaylist<Result>(
664
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>,
665
+
options: GRPCCore.CallOptions = .defaults,
666
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>) async throws -> Result = { response in
667
+
try response.message
668
+
}
669
+
) async throws -> Result where Result: Sendable {
670
+
try await self.deleteSavedPlaylist(
671
+
request: request,
672
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>(),
673
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>(),
674
+
options: options,
675
+
onResponse: handleResponse
676
+
)
677
+
}
678
+
679
+
internal func getSavedPlaylistTracks<Result>(
680
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>,
681
+
options: GRPCCore.CallOptions = .defaults,
682
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>) async throws -> Result = { response in
683
+
try response.message
684
+
}
685
+
) async throws -> Result where Result: Sendable {
686
+
try await self.getSavedPlaylistTracks(
687
+
request: request,
688
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>(),
689
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>(),
690
+
options: options,
691
+
onResponse: handleResponse
692
+
)
693
+
}
694
+
695
+
internal func addTracksToSavedPlaylist<Result>(
696
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>,
697
+
options: GRPCCore.CallOptions = .defaults,
698
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>) async throws -> Result = { response in
699
+
try response.message
700
+
}
701
+
) async throws -> Result where Result: Sendable {
702
+
try await self.addTracksToSavedPlaylist(
703
+
request: request,
704
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>(),
705
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>(),
706
+
options: options,
707
+
onResponse: handleResponse
708
+
)
709
+
}
710
+
711
+
internal func removeTrackFromSavedPlaylist<Result>(
712
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>,
713
+
options: GRPCCore.CallOptions = .defaults,
714
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>) async throws -> Result = { response in
715
+
try response.message
716
+
}
717
+
) async throws -> Result where Result: Sendable {
718
+
try await self.removeTrackFromSavedPlaylist(
719
+
request: request,
720
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>(),
721
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>(),
722
+
options: options,
723
+
onResponse: handleResponse
724
+
)
725
+
}
726
+
727
+
internal func playSavedPlaylist<Result>(
728
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySavedPlaylistRequest>,
729
+
options: GRPCCore.CallOptions = .defaults,
730
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySavedPlaylistResponse>) async throws -> Result = { response in
731
+
try response.message
732
+
}
733
+
) async throws -> Result where Result: Sendable {
734
+
try await self.playSavedPlaylist(
735
+
request: request,
736
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_PlaySavedPlaylistRequest>(),
737
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_PlaySavedPlaylistResponse>(),
738
+
options: options,
739
+
onResponse: handleResponse
740
+
)
741
+
}
742
+
}
743
+
744
+
// Helpers providing sugared APIs for 'ClientProtocol' methods.
745
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
746
+
extension Rockbox_V1alpha1_SavedPlaylistService.ClientProtocol {
747
+
internal func createPlaylistFolder<Result>(
748
+
_ message: Rockbox_V1alpha1_CreatePlaylistFolderRequest,
749
+
metadata: GRPCCore.Metadata = [:],
750
+
options: GRPCCore.CallOptions = .defaults,
751
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreatePlaylistFolderResponse>) async throws -> Result = { response in
752
+
try response.message
753
+
}
754
+
) async throws -> Result where Result: Sendable {
755
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_CreatePlaylistFolderRequest>(
756
+
message: message,
757
+
metadata: metadata
758
+
)
759
+
return try await self.createPlaylistFolder(
760
+
request: request,
761
+
options: options,
762
+
onResponse: handleResponse
763
+
)
764
+
}
765
+
766
+
internal func getPlaylistFolders<Result>(
767
+
_ message: Rockbox_V1alpha1_GetPlaylistFoldersRequest,
768
+
metadata: GRPCCore.Metadata = [:],
769
+
options: GRPCCore.CallOptions = .defaults,
770
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetPlaylistFoldersResponse>) async throws -> Result = { response in
771
+
try response.message
772
+
}
773
+
) async throws -> Result where Result: Sendable {
774
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetPlaylistFoldersRequest>(
775
+
message: message,
776
+
metadata: metadata
777
+
)
778
+
return try await self.getPlaylistFolders(
779
+
request: request,
780
+
options: options,
781
+
onResponse: handleResponse
782
+
)
783
+
}
784
+
785
+
internal func deletePlaylistFolder<Result>(
786
+
_ message: Rockbox_V1alpha1_DeletePlaylistFolderRequest,
787
+
metadata: GRPCCore.Metadata = [:],
788
+
options: GRPCCore.CallOptions = .defaults,
789
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeletePlaylistFolderResponse>) async throws -> Result = { response in
790
+
try response.message
791
+
}
792
+
) async throws -> Result where Result: Sendable {
793
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_DeletePlaylistFolderRequest>(
794
+
message: message,
795
+
metadata: metadata
796
+
)
797
+
return try await self.deletePlaylistFolder(
798
+
request: request,
799
+
options: options,
800
+
onResponse: handleResponse
801
+
)
802
+
}
803
+
804
+
internal func getSavedPlaylists<Result>(
805
+
_ message: Rockbox_V1alpha1_GetSavedPlaylistsRequest,
806
+
metadata: GRPCCore.Metadata = [:],
807
+
options: GRPCCore.CallOptions = .defaults,
808
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistsResponse>) async throws -> Result = { response in
809
+
try response.message
810
+
}
811
+
) async throws -> Result where Result: Sendable {
812
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistsRequest>(
813
+
message: message,
814
+
metadata: metadata
815
+
)
816
+
return try await self.getSavedPlaylists(
817
+
request: request,
818
+
options: options,
819
+
onResponse: handleResponse
820
+
)
821
+
}
822
+
823
+
internal func getSavedPlaylist<Result>(
824
+
_ message: Rockbox_V1alpha1_GetSavedPlaylistRequest,
825
+
metadata: GRPCCore.Metadata = [:],
826
+
options: GRPCCore.CallOptions = .defaults,
827
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistResponse>) async throws -> Result = { response in
828
+
try response.message
829
+
}
830
+
) async throws -> Result where Result: Sendable {
831
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistRequest>(
832
+
message: message,
833
+
metadata: metadata
834
+
)
835
+
return try await self.getSavedPlaylist(
836
+
request: request,
837
+
options: options,
838
+
onResponse: handleResponse
839
+
)
840
+
}
841
+
842
+
internal func createSavedPlaylist<Result>(
843
+
_ message: Rockbox_V1alpha1_CreateSavedPlaylistRequest,
844
+
metadata: GRPCCore.Metadata = [:],
845
+
options: GRPCCore.CallOptions = .defaults,
846
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSavedPlaylistResponse>) async throws -> Result = { response in
847
+
try response.message
848
+
}
849
+
) async throws -> Result where Result: Sendable {
850
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSavedPlaylistRequest>(
851
+
message: message,
852
+
metadata: metadata
853
+
)
854
+
return try await self.createSavedPlaylist(
855
+
request: request,
856
+
options: options,
857
+
onResponse: handleResponse
858
+
)
859
+
}
860
+
861
+
internal func updateSavedPlaylist<Result>(
862
+
_ message: Rockbox_V1alpha1_UpdateSavedPlaylistRequest,
863
+
metadata: GRPCCore.Metadata = [:],
864
+
options: GRPCCore.CallOptions = .defaults,
865
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSavedPlaylistResponse>) async throws -> Result = { response in
866
+
try response.message
867
+
}
868
+
) async throws -> Result where Result: Sendable {
869
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSavedPlaylistRequest>(
870
+
message: message,
871
+
metadata: metadata
872
+
)
873
+
return try await self.updateSavedPlaylist(
874
+
request: request,
875
+
options: options,
876
+
onResponse: handleResponse
877
+
)
878
+
}
879
+
880
+
internal func deleteSavedPlaylist<Result>(
881
+
_ message: Rockbox_V1alpha1_DeleteSavedPlaylistRequest,
882
+
metadata: GRPCCore.Metadata = [:],
883
+
options: GRPCCore.CallOptions = .defaults,
884
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSavedPlaylistResponse>) async throws -> Result = { response in
885
+
try response.message
886
+
}
887
+
) async throws -> Result where Result: Sendable {
888
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSavedPlaylistRequest>(
889
+
message: message,
890
+
metadata: metadata
891
+
)
892
+
return try await self.deleteSavedPlaylist(
893
+
request: request,
894
+
options: options,
895
+
onResponse: handleResponse
896
+
)
897
+
}
898
+
899
+
internal func getSavedPlaylistTracks<Result>(
900
+
_ message: Rockbox_V1alpha1_GetSavedPlaylistTracksRequest,
901
+
metadata: GRPCCore.Metadata = [:],
902
+
options: GRPCCore.CallOptions = .defaults,
903
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSavedPlaylistTracksResponse>) async throws -> Result = { response in
904
+
try response.message
905
+
}
906
+
) async throws -> Result where Result: Sendable {
907
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSavedPlaylistTracksRequest>(
908
+
message: message,
909
+
metadata: metadata
910
+
)
911
+
return try await self.getSavedPlaylistTracks(
912
+
request: request,
913
+
options: options,
914
+
onResponse: handleResponse
915
+
)
916
+
}
917
+
918
+
internal func addTracksToSavedPlaylist<Result>(
919
+
_ message: Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest,
920
+
metadata: GRPCCore.Metadata = [:],
921
+
options: GRPCCore.CallOptions = .defaults,
922
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse>) async throws -> Result = { response in
923
+
try response.message
924
+
}
925
+
) async throws -> Result where Result: Sendable {
926
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest>(
927
+
message: message,
928
+
metadata: metadata
929
+
)
930
+
return try await self.addTracksToSavedPlaylist(
931
+
request: request,
932
+
options: options,
933
+
onResponse: handleResponse
934
+
)
935
+
}
936
+
937
+
internal func removeTrackFromSavedPlaylist<Result>(
938
+
_ message: Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest,
939
+
metadata: GRPCCore.Metadata = [:],
940
+
options: GRPCCore.CallOptions = .defaults,
941
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse>) async throws -> Result = { response in
942
+
try response.message
943
+
}
944
+
) async throws -> Result where Result: Sendable {
945
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest>(
946
+
message: message,
947
+
metadata: metadata
948
+
)
949
+
return try await self.removeTrackFromSavedPlaylist(
950
+
request: request,
951
+
options: options,
952
+
onResponse: handleResponse
953
+
)
954
+
}
955
+
956
+
internal func playSavedPlaylist<Result>(
957
+
_ message: Rockbox_V1alpha1_PlaySavedPlaylistRequest,
958
+
metadata: GRPCCore.Metadata = [:],
959
+
options: GRPCCore.CallOptions = .defaults,
960
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySavedPlaylistResponse>) async throws -> Result = { response in
961
+
try response.message
962
+
}
963
+
) async throws -> Result where Result: Sendable {
964
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySavedPlaylistRequest>(
965
+
message: message,
966
+
metadata: metadata
967
+
)
968
+
return try await self.playSavedPlaylist(
969
+
request: request,
970
+
options: options,
971
+
onResponse: handleResponse
972
+
)
973
+
}
974
+
}
+1305
macos/Rockbox/Services/rockbox/v1alpha1/saved_playlist.pb.swift
+1305
macos/Rockbox/Services/rockbox/v1alpha1/saved_playlist.pb.swift
···
1
+
// DO NOT EDIT.
2
+
// swift-format-ignore-file
3
+
// swiftlint:disable all
4
+
//
5
+
// Generated by the Swift generator plugin for the protocol buffer compiler.
6
+
// Source: rockbox/v1alpha1/saved_playlist.proto
7
+
//
8
+
// For information on using the generated types, please see the documentation:
9
+
// https://github.com/apple/swift-protobuf/
10
+
11
+
import SwiftProtobuf
12
+
13
+
// If the compiler emits an error on this type, it is because this file
14
+
// was generated by a version of the `protoc` Swift plug-in that is
15
+
// incompatible with the version of SwiftProtobuf to which you are linking.
16
+
// Please ensure that you are building against the same version of the API
17
+
// that was used to generate this file.
18
+
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
19
+
struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
20
+
typealias Version = _2
21
+
}
22
+
23
+
struct Rockbox_V1alpha1_PlaylistFolder: Sendable {
24
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
25
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
26
+
// methods supported on all messages.
27
+
28
+
var id: String = String()
29
+
30
+
var name: String = String()
31
+
32
+
var createdAt: Int64 = 0
33
+
34
+
var updatedAt: Int64 = 0
35
+
36
+
var unknownFields = SwiftProtobuf.UnknownStorage()
37
+
38
+
init() {}
39
+
}
40
+
41
+
struct Rockbox_V1alpha1_CreatePlaylistFolderRequest: Sendable {
42
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
43
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
44
+
// methods supported on all messages.
45
+
46
+
var name: String = String()
47
+
48
+
var unknownFields = SwiftProtobuf.UnknownStorage()
49
+
50
+
init() {}
51
+
}
52
+
53
+
struct Rockbox_V1alpha1_CreatePlaylistFolderResponse: Sendable {
54
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
55
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
56
+
// methods supported on all messages.
57
+
58
+
var folder: Rockbox_V1alpha1_PlaylistFolder {
59
+
get {return _folder ?? Rockbox_V1alpha1_PlaylistFolder()}
60
+
set {_folder = newValue}
61
+
}
62
+
/// Returns true if `folder` has been explicitly set.
63
+
var hasFolder: Bool {return self._folder != nil}
64
+
/// Clears the value of `folder`. Subsequent reads from it will return its default value.
65
+
mutating func clearFolder() {self._folder = nil}
66
+
67
+
var unknownFields = SwiftProtobuf.UnknownStorage()
68
+
69
+
init() {}
70
+
71
+
fileprivate var _folder: Rockbox_V1alpha1_PlaylistFolder? = nil
72
+
}
73
+
74
+
struct Rockbox_V1alpha1_GetPlaylistFoldersRequest: Sendable {
75
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
76
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
77
+
// methods supported on all messages.
78
+
79
+
var unknownFields = SwiftProtobuf.UnknownStorage()
80
+
81
+
init() {}
82
+
}
83
+
84
+
struct Rockbox_V1alpha1_GetPlaylistFoldersResponse: Sendable {
85
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
86
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
87
+
// methods supported on all messages.
88
+
89
+
var folders: [Rockbox_V1alpha1_PlaylistFolder] = []
90
+
91
+
var unknownFields = SwiftProtobuf.UnknownStorage()
92
+
93
+
init() {}
94
+
}
95
+
96
+
struct Rockbox_V1alpha1_DeletePlaylistFolderRequest: Sendable {
97
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
98
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
99
+
// methods supported on all messages.
100
+
101
+
var id: String = String()
102
+
103
+
var unknownFields = SwiftProtobuf.UnknownStorage()
104
+
105
+
init() {}
106
+
}
107
+
108
+
struct Rockbox_V1alpha1_DeletePlaylistFolderResponse: Sendable {
109
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
110
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
111
+
// methods supported on all messages.
112
+
113
+
var unknownFields = SwiftProtobuf.UnknownStorage()
114
+
115
+
init() {}
116
+
}
117
+
118
+
struct Rockbox_V1alpha1_SavedPlaylist: Sendable {
119
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
120
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
121
+
// methods supported on all messages.
122
+
123
+
var id: String = String()
124
+
125
+
var name: String = String()
126
+
127
+
var description_p: String {
128
+
get {return _description_p ?? String()}
129
+
set {_description_p = newValue}
130
+
}
131
+
/// Returns true if `description_p` has been explicitly set.
132
+
var hasDescription_p: Bool {return self._description_p != nil}
133
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
134
+
mutating func clearDescription_p() {self._description_p = nil}
135
+
136
+
var image: String {
137
+
get {return _image ?? String()}
138
+
set {_image = newValue}
139
+
}
140
+
/// Returns true if `image` has been explicitly set.
141
+
var hasImage: Bool {return self._image != nil}
142
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
143
+
mutating func clearImage() {self._image = nil}
144
+
145
+
var folderID: String {
146
+
get {return _folderID ?? String()}
147
+
set {_folderID = newValue}
148
+
}
149
+
/// Returns true if `folderID` has been explicitly set.
150
+
var hasFolderID: Bool {return self._folderID != nil}
151
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
152
+
mutating func clearFolderID() {self._folderID = nil}
153
+
154
+
var trackCount: Int64 = 0
155
+
156
+
var createdAt: Int64 = 0
157
+
158
+
var updatedAt: Int64 = 0
159
+
160
+
var unknownFields = SwiftProtobuf.UnknownStorage()
161
+
162
+
init() {}
163
+
164
+
fileprivate var _description_p: String? = nil
165
+
fileprivate var _image: String? = nil
166
+
fileprivate var _folderID: String? = nil
167
+
}
168
+
169
+
struct Rockbox_V1alpha1_GetSavedPlaylistsRequest: Sendable {
170
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
171
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
172
+
// methods supported on all messages.
173
+
174
+
var folderID: String {
175
+
get {return _folderID ?? String()}
176
+
set {_folderID = newValue}
177
+
}
178
+
/// Returns true if `folderID` has been explicitly set.
179
+
var hasFolderID: Bool {return self._folderID != nil}
180
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
181
+
mutating func clearFolderID() {self._folderID = nil}
182
+
183
+
var unknownFields = SwiftProtobuf.UnknownStorage()
184
+
185
+
init() {}
186
+
187
+
fileprivate var _folderID: String? = nil
188
+
}
189
+
190
+
struct Rockbox_V1alpha1_GetSavedPlaylistsResponse: Sendable {
191
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
192
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
193
+
// methods supported on all messages.
194
+
195
+
var playlists: [Rockbox_V1alpha1_SavedPlaylist] = []
196
+
197
+
var unknownFields = SwiftProtobuf.UnknownStorage()
198
+
199
+
init() {}
200
+
}
201
+
202
+
struct Rockbox_V1alpha1_GetSavedPlaylistRequest: Sendable {
203
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
204
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
205
+
// methods supported on all messages.
206
+
207
+
var id: String = String()
208
+
209
+
var unknownFields = SwiftProtobuf.UnknownStorage()
210
+
211
+
init() {}
212
+
}
213
+
214
+
struct Rockbox_V1alpha1_GetSavedPlaylistResponse: Sendable {
215
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
216
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
217
+
// methods supported on all messages.
218
+
219
+
var playlist: Rockbox_V1alpha1_SavedPlaylist {
220
+
get {return _playlist ?? Rockbox_V1alpha1_SavedPlaylist()}
221
+
set {_playlist = newValue}
222
+
}
223
+
/// Returns true if `playlist` has been explicitly set.
224
+
var hasPlaylist: Bool {return self._playlist != nil}
225
+
/// Clears the value of `playlist`. Subsequent reads from it will return its default value.
226
+
mutating func clearPlaylist() {self._playlist = nil}
227
+
228
+
var unknownFields = SwiftProtobuf.UnknownStorage()
229
+
230
+
init() {}
231
+
232
+
fileprivate var _playlist: Rockbox_V1alpha1_SavedPlaylist? = nil
233
+
}
234
+
235
+
struct Rockbox_V1alpha1_CreateSavedPlaylistRequest: Sendable {
236
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
237
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
238
+
// methods supported on all messages.
239
+
240
+
var name: String = String()
241
+
242
+
var description_p: String {
243
+
get {return _description_p ?? String()}
244
+
set {_description_p = newValue}
245
+
}
246
+
/// Returns true if `description_p` has been explicitly set.
247
+
var hasDescription_p: Bool {return self._description_p != nil}
248
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
249
+
mutating func clearDescription_p() {self._description_p = nil}
250
+
251
+
var image: String {
252
+
get {return _image ?? String()}
253
+
set {_image = newValue}
254
+
}
255
+
/// Returns true if `image` has been explicitly set.
256
+
var hasImage: Bool {return self._image != nil}
257
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
258
+
mutating func clearImage() {self._image = nil}
259
+
260
+
var folderID: String {
261
+
get {return _folderID ?? String()}
262
+
set {_folderID = newValue}
263
+
}
264
+
/// Returns true if `folderID` has been explicitly set.
265
+
var hasFolderID: Bool {return self._folderID != nil}
266
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
267
+
mutating func clearFolderID() {self._folderID = nil}
268
+
269
+
var trackIDs: [String] = []
270
+
271
+
var unknownFields = SwiftProtobuf.UnknownStorage()
272
+
273
+
init() {}
274
+
275
+
fileprivate var _description_p: String? = nil
276
+
fileprivate var _image: String? = nil
277
+
fileprivate var _folderID: String? = nil
278
+
}
279
+
280
+
struct Rockbox_V1alpha1_CreateSavedPlaylistResponse: Sendable {
281
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
282
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
283
+
// methods supported on all messages.
284
+
285
+
var playlist: Rockbox_V1alpha1_SavedPlaylist {
286
+
get {return _playlist ?? Rockbox_V1alpha1_SavedPlaylist()}
287
+
set {_playlist = newValue}
288
+
}
289
+
/// Returns true if `playlist` has been explicitly set.
290
+
var hasPlaylist: Bool {return self._playlist != nil}
291
+
/// Clears the value of `playlist`. Subsequent reads from it will return its default value.
292
+
mutating func clearPlaylist() {self._playlist = nil}
293
+
294
+
var unknownFields = SwiftProtobuf.UnknownStorage()
295
+
296
+
init() {}
297
+
298
+
fileprivate var _playlist: Rockbox_V1alpha1_SavedPlaylist? = nil
299
+
}
300
+
301
+
struct Rockbox_V1alpha1_UpdateSavedPlaylistRequest: Sendable {
302
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
303
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
304
+
// methods supported on all messages.
305
+
306
+
var id: String = String()
307
+
308
+
var name: String = String()
309
+
310
+
var description_p: String {
311
+
get {return _description_p ?? String()}
312
+
set {_description_p = newValue}
313
+
}
314
+
/// Returns true if `description_p` has been explicitly set.
315
+
var hasDescription_p: Bool {return self._description_p != nil}
316
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
317
+
mutating func clearDescription_p() {self._description_p = nil}
318
+
319
+
var image: String {
320
+
get {return _image ?? String()}
321
+
set {_image = newValue}
322
+
}
323
+
/// Returns true if `image` has been explicitly set.
324
+
var hasImage: Bool {return self._image != nil}
325
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
326
+
mutating func clearImage() {self._image = nil}
327
+
328
+
var folderID: String {
329
+
get {return _folderID ?? String()}
330
+
set {_folderID = newValue}
331
+
}
332
+
/// Returns true if `folderID` has been explicitly set.
333
+
var hasFolderID: Bool {return self._folderID != nil}
334
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
335
+
mutating func clearFolderID() {self._folderID = nil}
336
+
337
+
var unknownFields = SwiftProtobuf.UnknownStorage()
338
+
339
+
init() {}
340
+
341
+
fileprivate var _description_p: String? = nil
342
+
fileprivate var _image: String? = nil
343
+
fileprivate var _folderID: String? = nil
344
+
}
345
+
346
+
struct Rockbox_V1alpha1_UpdateSavedPlaylistResponse: Sendable {
347
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
348
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
349
+
// methods supported on all messages.
350
+
351
+
var unknownFields = SwiftProtobuf.UnknownStorage()
352
+
353
+
init() {}
354
+
}
355
+
356
+
struct Rockbox_V1alpha1_DeleteSavedPlaylistRequest: Sendable {
357
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
358
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
359
+
// methods supported on all messages.
360
+
361
+
var id: String = String()
362
+
363
+
var unknownFields = SwiftProtobuf.UnknownStorage()
364
+
365
+
init() {}
366
+
}
367
+
368
+
struct Rockbox_V1alpha1_DeleteSavedPlaylistResponse: Sendable {
369
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
370
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
371
+
// methods supported on all messages.
372
+
373
+
var unknownFields = SwiftProtobuf.UnknownStorage()
374
+
375
+
init() {}
376
+
}
377
+
378
+
struct Rockbox_V1alpha1_GetSavedPlaylistTracksRequest: Sendable {
379
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
380
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
381
+
// methods supported on all messages.
382
+
383
+
var playlistID: String = String()
384
+
385
+
var unknownFields = SwiftProtobuf.UnknownStorage()
386
+
387
+
init() {}
388
+
}
389
+
390
+
struct Rockbox_V1alpha1_GetSavedPlaylistTracksResponse: Sendable {
391
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
392
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
393
+
// methods supported on all messages.
394
+
395
+
var trackIDs: [String] = []
396
+
397
+
var unknownFields = SwiftProtobuf.UnknownStorage()
398
+
399
+
init() {}
400
+
}
401
+
402
+
struct Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest: Sendable {
403
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
404
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
405
+
// methods supported on all messages.
406
+
407
+
var playlistID: String = String()
408
+
409
+
var trackIDs: [String] = []
410
+
411
+
var unknownFields = SwiftProtobuf.UnknownStorage()
412
+
413
+
init() {}
414
+
}
415
+
416
+
struct Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse: Sendable {
417
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
418
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
419
+
// methods supported on all messages.
420
+
421
+
var unknownFields = SwiftProtobuf.UnknownStorage()
422
+
423
+
init() {}
424
+
}
425
+
426
+
struct Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest: Sendable {
427
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
428
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
429
+
// methods supported on all messages.
430
+
431
+
var playlistID: String = String()
432
+
433
+
var trackID: String = String()
434
+
435
+
var unknownFields = SwiftProtobuf.UnknownStorage()
436
+
437
+
init() {}
438
+
}
439
+
440
+
struct Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse: Sendable {
441
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
442
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
443
+
// methods supported on all messages.
444
+
445
+
var unknownFields = SwiftProtobuf.UnknownStorage()
446
+
447
+
init() {}
448
+
}
449
+
450
+
struct Rockbox_V1alpha1_PlaySavedPlaylistRequest: Sendable {
451
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
452
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
453
+
// methods supported on all messages.
454
+
455
+
var playlistID: String = String()
456
+
457
+
var unknownFields = SwiftProtobuf.UnknownStorage()
458
+
459
+
init() {}
460
+
}
461
+
462
+
struct Rockbox_V1alpha1_PlaySavedPlaylistResponse: Sendable {
463
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
464
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
465
+
// methods supported on all messages.
466
+
467
+
var unknownFields = SwiftProtobuf.UnknownStorage()
468
+
469
+
init() {}
470
+
}
471
+
472
+
// MARK: - Code below here is support for the SwiftProtobuf runtime.
473
+
474
+
fileprivate let _protobuf_package = "rockbox.v1alpha1"
475
+
476
+
extension Rockbox_V1alpha1_PlaylistFolder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
477
+
static let protoMessageName: String = _protobuf_package + ".PlaylistFolder"
478
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}name\0\u{3}created_at\0\u{3}updated_at\0")
479
+
480
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
481
+
while let fieldNumber = try decoder.nextFieldNumber() {
482
+
// The use of inline closures is to circumvent an issue where the compiler
483
+
// allocates stack space for every case branch when no optimizations are
484
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
485
+
switch fieldNumber {
486
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
487
+
case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
488
+
case 3: try { try decoder.decodeSingularInt64Field(value: &self.createdAt) }()
489
+
case 4: try { try decoder.decodeSingularInt64Field(value: &self.updatedAt) }()
490
+
default: break
491
+
}
492
+
}
493
+
}
494
+
495
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
496
+
if !self.id.isEmpty {
497
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
498
+
}
499
+
if !self.name.isEmpty {
500
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
501
+
}
502
+
if self.createdAt != 0 {
503
+
try visitor.visitSingularInt64Field(value: self.createdAt, fieldNumber: 3)
504
+
}
505
+
if self.updatedAt != 0 {
506
+
try visitor.visitSingularInt64Field(value: self.updatedAt, fieldNumber: 4)
507
+
}
508
+
try unknownFields.traverse(visitor: &visitor)
509
+
}
510
+
511
+
static func ==(lhs: Rockbox_V1alpha1_PlaylistFolder, rhs: Rockbox_V1alpha1_PlaylistFolder) -> Bool {
512
+
if lhs.id != rhs.id {return false}
513
+
if lhs.name != rhs.name {return false}
514
+
if lhs.createdAt != rhs.createdAt {return false}
515
+
if lhs.updatedAt != rhs.updatedAt {return false}
516
+
if lhs.unknownFields != rhs.unknownFields {return false}
517
+
return true
518
+
}
519
+
}
520
+
521
+
extension Rockbox_V1alpha1_CreatePlaylistFolderRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
522
+
static let protoMessageName: String = _protobuf_package + ".CreatePlaylistFolderRequest"
523
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0")
524
+
525
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
526
+
while let fieldNumber = try decoder.nextFieldNumber() {
527
+
// The use of inline closures is to circumvent an issue where the compiler
528
+
// allocates stack space for every case branch when no optimizations are
529
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
530
+
switch fieldNumber {
531
+
case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
532
+
default: break
533
+
}
534
+
}
535
+
}
536
+
537
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
538
+
if !self.name.isEmpty {
539
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
540
+
}
541
+
try unknownFields.traverse(visitor: &visitor)
542
+
}
543
+
544
+
static func ==(lhs: Rockbox_V1alpha1_CreatePlaylistFolderRequest, rhs: Rockbox_V1alpha1_CreatePlaylistFolderRequest) -> Bool {
545
+
if lhs.name != rhs.name {return false}
546
+
if lhs.unknownFields != rhs.unknownFields {return false}
547
+
return true
548
+
}
549
+
}
550
+
551
+
extension Rockbox_V1alpha1_CreatePlaylistFolderResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
552
+
static let protoMessageName: String = _protobuf_package + ".CreatePlaylistFolderResponse"
553
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}folder\0")
554
+
555
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
556
+
while let fieldNumber = try decoder.nextFieldNumber() {
557
+
// The use of inline closures is to circumvent an issue where the compiler
558
+
// allocates stack space for every case branch when no optimizations are
559
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
560
+
switch fieldNumber {
561
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._folder) }()
562
+
default: break
563
+
}
564
+
}
565
+
}
566
+
567
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
568
+
// The use of inline closures is to circumvent an issue where the compiler
569
+
// allocates stack space for every if/case branch local when no optimizations
570
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
571
+
// https://github.com/apple/swift-protobuf/issues/1182
572
+
try { if let v = self._folder {
573
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
574
+
} }()
575
+
try unknownFields.traverse(visitor: &visitor)
576
+
}
577
+
578
+
static func ==(lhs: Rockbox_V1alpha1_CreatePlaylistFolderResponse, rhs: Rockbox_V1alpha1_CreatePlaylistFolderResponse) -> Bool {
579
+
if lhs._folder != rhs._folder {return false}
580
+
if lhs.unknownFields != rhs.unknownFields {return false}
581
+
return true
582
+
}
583
+
}
584
+
585
+
extension Rockbox_V1alpha1_GetPlaylistFoldersRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
586
+
static let protoMessageName: String = _protobuf_package + ".GetPlaylistFoldersRequest"
587
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
588
+
589
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
590
+
// Load everything into unknown fields
591
+
while try decoder.nextFieldNumber() != nil {}
592
+
}
593
+
594
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
595
+
try unknownFields.traverse(visitor: &visitor)
596
+
}
597
+
598
+
static func ==(lhs: Rockbox_V1alpha1_GetPlaylistFoldersRequest, rhs: Rockbox_V1alpha1_GetPlaylistFoldersRequest) -> Bool {
599
+
if lhs.unknownFields != rhs.unknownFields {return false}
600
+
return true
601
+
}
602
+
}
603
+
604
+
extension Rockbox_V1alpha1_GetPlaylistFoldersResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
605
+
static let protoMessageName: String = _protobuf_package + ".GetPlaylistFoldersResponse"
606
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}folders\0")
607
+
608
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
609
+
while let fieldNumber = try decoder.nextFieldNumber() {
610
+
// The use of inline closures is to circumvent an issue where the compiler
611
+
// allocates stack space for every case branch when no optimizations are
612
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
613
+
switch fieldNumber {
614
+
case 1: try { try decoder.decodeRepeatedMessageField(value: &self.folders) }()
615
+
default: break
616
+
}
617
+
}
618
+
}
619
+
620
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
621
+
if !self.folders.isEmpty {
622
+
try visitor.visitRepeatedMessageField(value: self.folders, fieldNumber: 1)
623
+
}
624
+
try unknownFields.traverse(visitor: &visitor)
625
+
}
626
+
627
+
static func ==(lhs: Rockbox_V1alpha1_GetPlaylistFoldersResponse, rhs: Rockbox_V1alpha1_GetPlaylistFoldersResponse) -> Bool {
628
+
if lhs.folders != rhs.folders {return false}
629
+
if lhs.unknownFields != rhs.unknownFields {return false}
630
+
return true
631
+
}
632
+
}
633
+
634
+
extension Rockbox_V1alpha1_DeletePlaylistFolderRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
635
+
static let protoMessageName: String = _protobuf_package + ".DeletePlaylistFolderRequest"
636
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
637
+
638
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
639
+
while let fieldNumber = try decoder.nextFieldNumber() {
640
+
// The use of inline closures is to circumvent an issue where the compiler
641
+
// allocates stack space for every case branch when no optimizations are
642
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
643
+
switch fieldNumber {
644
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
645
+
default: break
646
+
}
647
+
}
648
+
}
649
+
650
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
651
+
if !self.id.isEmpty {
652
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
653
+
}
654
+
try unknownFields.traverse(visitor: &visitor)
655
+
}
656
+
657
+
static func ==(lhs: Rockbox_V1alpha1_DeletePlaylistFolderRequest, rhs: Rockbox_V1alpha1_DeletePlaylistFolderRequest) -> Bool {
658
+
if lhs.id != rhs.id {return false}
659
+
if lhs.unknownFields != rhs.unknownFields {return false}
660
+
return true
661
+
}
662
+
}
663
+
664
+
extension Rockbox_V1alpha1_DeletePlaylistFolderResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
665
+
static let protoMessageName: String = _protobuf_package + ".DeletePlaylistFolderResponse"
666
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
667
+
668
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
669
+
// Load everything into unknown fields
670
+
while try decoder.nextFieldNumber() != nil {}
671
+
}
672
+
673
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
674
+
try unknownFields.traverse(visitor: &visitor)
675
+
}
676
+
677
+
static func ==(lhs: Rockbox_V1alpha1_DeletePlaylistFolderResponse, rhs: Rockbox_V1alpha1_DeletePlaylistFolderResponse) -> Bool {
678
+
if lhs.unknownFields != rhs.unknownFields {return false}
679
+
return true
680
+
}
681
+
}
682
+
683
+
extension Rockbox_V1alpha1_SavedPlaylist: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
684
+
static let protoMessageName: String = _protobuf_package + ".SavedPlaylist"
685
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0\u{3}track_count\0\u{3}created_at\0\u{3}updated_at\0")
686
+
687
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
688
+
while let fieldNumber = try decoder.nextFieldNumber() {
689
+
// The use of inline closures is to circumvent an issue where the compiler
690
+
// allocates stack space for every case branch when no optimizations are
691
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
692
+
switch fieldNumber {
693
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
694
+
case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
695
+
case 3: try { try decoder.decodeSingularStringField(value: &self._description_p) }()
696
+
case 4: try { try decoder.decodeSingularStringField(value: &self._image) }()
697
+
case 5: try { try decoder.decodeSingularStringField(value: &self._folderID) }()
698
+
case 6: try { try decoder.decodeSingularInt64Field(value: &self.trackCount) }()
699
+
case 7: try { try decoder.decodeSingularInt64Field(value: &self.createdAt) }()
700
+
case 8: try { try decoder.decodeSingularInt64Field(value: &self.updatedAt) }()
701
+
default: break
702
+
}
703
+
}
704
+
}
705
+
706
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
707
+
// The use of inline closures is to circumvent an issue where the compiler
708
+
// allocates stack space for every if/case branch local when no optimizations
709
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
710
+
// https://github.com/apple/swift-protobuf/issues/1182
711
+
if !self.id.isEmpty {
712
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
713
+
}
714
+
if !self.name.isEmpty {
715
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
716
+
}
717
+
try { if let v = self._description_p {
718
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
719
+
} }()
720
+
try { if let v = self._image {
721
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
722
+
} }()
723
+
try { if let v = self._folderID {
724
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
725
+
} }()
726
+
if self.trackCount != 0 {
727
+
try visitor.visitSingularInt64Field(value: self.trackCount, fieldNumber: 6)
728
+
}
729
+
if self.createdAt != 0 {
730
+
try visitor.visitSingularInt64Field(value: self.createdAt, fieldNumber: 7)
731
+
}
732
+
if self.updatedAt != 0 {
733
+
try visitor.visitSingularInt64Field(value: self.updatedAt, fieldNumber: 8)
734
+
}
735
+
try unknownFields.traverse(visitor: &visitor)
736
+
}
737
+
738
+
static func ==(lhs: Rockbox_V1alpha1_SavedPlaylist, rhs: Rockbox_V1alpha1_SavedPlaylist) -> Bool {
739
+
if lhs.id != rhs.id {return false}
740
+
if lhs.name != rhs.name {return false}
741
+
if lhs._description_p != rhs._description_p {return false}
742
+
if lhs._image != rhs._image {return false}
743
+
if lhs._folderID != rhs._folderID {return false}
744
+
if lhs.trackCount != rhs.trackCount {return false}
745
+
if lhs.createdAt != rhs.createdAt {return false}
746
+
if lhs.updatedAt != rhs.updatedAt {return false}
747
+
if lhs.unknownFields != rhs.unknownFields {return false}
748
+
return true
749
+
}
750
+
}
751
+
752
+
extension Rockbox_V1alpha1_GetSavedPlaylistsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
753
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistsRequest"
754
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}folder_id\0")
755
+
756
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
757
+
while let fieldNumber = try decoder.nextFieldNumber() {
758
+
// The use of inline closures is to circumvent an issue where the compiler
759
+
// allocates stack space for every case branch when no optimizations are
760
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
761
+
switch fieldNumber {
762
+
case 1: try { try decoder.decodeSingularStringField(value: &self._folderID) }()
763
+
default: break
764
+
}
765
+
}
766
+
}
767
+
768
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
769
+
// The use of inline closures is to circumvent an issue where the compiler
770
+
// allocates stack space for every if/case branch local when no optimizations
771
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
772
+
// https://github.com/apple/swift-protobuf/issues/1182
773
+
try { if let v = self._folderID {
774
+
try visitor.visitSingularStringField(value: v, fieldNumber: 1)
775
+
} }()
776
+
try unknownFields.traverse(visitor: &visitor)
777
+
}
778
+
779
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistsRequest, rhs: Rockbox_V1alpha1_GetSavedPlaylistsRequest) -> Bool {
780
+
if lhs._folderID != rhs._folderID {return false}
781
+
if lhs.unknownFields != rhs.unknownFields {return false}
782
+
return true
783
+
}
784
+
}
785
+
786
+
extension Rockbox_V1alpha1_GetSavedPlaylistsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
787
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistsResponse"
788
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlists\0")
789
+
790
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
791
+
while let fieldNumber = try decoder.nextFieldNumber() {
792
+
// The use of inline closures is to circumvent an issue where the compiler
793
+
// allocates stack space for every case branch when no optimizations are
794
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
795
+
switch fieldNumber {
796
+
case 1: try { try decoder.decodeRepeatedMessageField(value: &self.playlists) }()
797
+
default: break
798
+
}
799
+
}
800
+
}
801
+
802
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
803
+
if !self.playlists.isEmpty {
804
+
try visitor.visitRepeatedMessageField(value: self.playlists, fieldNumber: 1)
805
+
}
806
+
try unknownFields.traverse(visitor: &visitor)
807
+
}
808
+
809
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistsResponse, rhs: Rockbox_V1alpha1_GetSavedPlaylistsResponse) -> Bool {
810
+
if lhs.playlists != rhs.playlists {return false}
811
+
if lhs.unknownFields != rhs.unknownFields {return false}
812
+
return true
813
+
}
814
+
}
815
+
816
+
extension Rockbox_V1alpha1_GetSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
817
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistRequest"
818
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
819
+
820
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
821
+
while let fieldNumber = try decoder.nextFieldNumber() {
822
+
// The use of inline closures is to circumvent an issue where the compiler
823
+
// allocates stack space for every case branch when no optimizations are
824
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
825
+
switch fieldNumber {
826
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
827
+
default: break
828
+
}
829
+
}
830
+
}
831
+
832
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
833
+
if !self.id.isEmpty {
834
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
835
+
}
836
+
try unknownFields.traverse(visitor: &visitor)
837
+
}
838
+
839
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistRequest, rhs: Rockbox_V1alpha1_GetSavedPlaylistRequest) -> Bool {
840
+
if lhs.id != rhs.id {return false}
841
+
if lhs.unknownFields != rhs.unknownFields {return false}
842
+
return true
843
+
}
844
+
}
845
+
846
+
extension Rockbox_V1alpha1_GetSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
847
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistResponse"
848
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlist\0")
849
+
850
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
851
+
while let fieldNumber = try decoder.nextFieldNumber() {
852
+
// The use of inline closures is to circumvent an issue where the compiler
853
+
// allocates stack space for every case branch when no optimizations are
854
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
855
+
switch fieldNumber {
856
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._playlist) }()
857
+
default: break
858
+
}
859
+
}
860
+
}
861
+
862
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
863
+
// The use of inline closures is to circumvent an issue where the compiler
864
+
// allocates stack space for every if/case branch local when no optimizations
865
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
866
+
// https://github.com/apple/swift-protobuf/issues/1182
867
+
try { if let v = self._playlist {
868
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
869
+
} }()
870
+
try unknownFields.traverse(visitor: &visitor)
871
+
}
872
+
873
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistResponse, rhs: Rockbox_V1alpha1_GetSavedPlaylistResponse) -> Bool {
874
+
if lhs._playlist != rhs._playlist {return false}
875
+
if lhs.unknownFields != rhs.unknownFields {return false}
876
+
return true
877
+
}
878
+
}
879
+
880
+
extension Rockbox_V1alpha1_CreateSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
881
+
static let protoMessageName: String = _protobuf_package + ".CreateSavedPlaylistRequest"
882
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0\u{3}track_ids\0")
883
+
884
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
885
+
while let fieldNumber = try decoder.nextFieldNumber() {
886
+
// The use of inline closures is to circumvent an issue where the compiler
887
+
// allocates stack space for every case branch when no optimizations are
888
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
889
+
switch fieldNumber {
890
+
case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
891
+
case 2: try { try decoder.decodeSingularStringField(value: &self._description_p) }()
892
+
case 3: try { try decoder.decodeSingularStringField(value: &self._image) }()
893
+
case 4: try { try decoder.decodeSingularStringField(value: &self._folderID) }()
894
+
case 5: try { try decoder.decodeRepeatedStringField(value: &self.trackIDs) }()
895
+
default: break
896
+
}
897
+
}
898
+
}
899
+
900
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
901
+
// The use of inline closures is to circumvent an issue where the compiler
902
+
// allocates stack space for every if/case branch local when no optimizations
903
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
904
+
// https://github.com/apple/swift-protobuf/issues/1182
905
+
if !self.name.isEmpty {
906
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
907
+
}
908
+
try { if let v = self._description_p {
909
+
try visitor.visitSingularStringField(value: v, fieldNumber: 2)
910
+
} }()
911
+
try { if let v = self._image {
912
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
913
+
} }()
914
+
try { if let v = self._folderID {
915
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
916
+
} }()
917
+
if !self.trackIDs.isEmpty {
918
+
try visitor.visitRepeatedStringField(value: self.trackIDs, fieldNumber: 5)
919
+
}
920
+
try unknownFields.traverse(visitor: &visitor)
921
+
}
922
+
923
+
static func ==(lhs: Rockbox_V1alpha1_CreateSavedPlaylistRequest, rhs: Rockbox_V1alpha1_CreateSavedPlaylistRequest) -> Bool {
924
+
if lhs.name != rhs.name {return false}
925
+
if lhs._description_p != rhs._description_p {return false}
926
+
if lhs._image != rhs._image {return false}
927
+
if lhs._folderID != rhs._folderID {return false}
928
+
if lhs.trackIDs != rhs.trackIDs {return false}
929
+
if lhs.unknownFields != rhs.unknownFields {return false}
930
+
return true
931
+
}
932
+
}
933
+
934
+
extension Rockbox_V1alpha1_CreateSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
935
+
static let protoMessageName: String = _protobuf_package + ".CreateSavedPlaylistResponse"
936
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlist\0")
937
+
938
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
939
+
while let fieldNumber = try decoder.nextFieldNumber() {
940
+
// The use of inline closures is to circumvent an issue where the compiler
941
+
// allocates stack space for every case branch when no optimizations are
942
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
943
+
switch fieldNumber {
944
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._playlist) }()
945
+
default: break
946
+
}
947
+
}
948
+
}
949
+
950
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
951
+
// The use of inline closures is to circumvent an issue where the compiler
952
+
// allocates stack space for every if/case branch local when no optimizations
953
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
954
+
// https://github.com/apple/swift-protobuf/issues/1182
955
+
try { if let v = self._playlist {
956
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
957
+
} }()
958
+
try unknownFields.traverse(visitor: &visitor)
959
+
}
960
+
961
+
static func ==(lhs: Rockbox_V1alpha1_CreateSavedPlaylistResponse, rhs: Rockbox_V1alpha1_CreateSavedPlaylistResponse) -> Bool {
962
+
if lhs._playlist != rhs._playlist {return false}
963
+
if lhs.unknownFields != rhs.unknownFields {return false}
964
+
return true
965
+
}
966
+
}
967
+
968
+
extension Rockbox_V1alpha1_UpdateSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
969
+
static let protoMessageName: String = _protobuf_package + ".UpdateSavedPlaylistRequest"
970
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0")
971
+
972
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
973
+
while let fieldNumber = try decoder.nextFieldNumber() {
974
+
// The use of inline closures is to circumvent an issue where the compiler
975
+
// allocates stack space for every case branch when no optimizations are
976
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
977
+
switch fieldNumber {
978
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
979
+
case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
980
+
case 3: try { try decoder.decodeSingularStringField(value: &self._description_p) }()
981
+
case 4: try { try decoder.decodeSingularStringField(value: &self._image) }()
982
+
case 5: try { try decoder.decodeSingularStringField(value: &self._folderID) }()
983
+
default: break
984
+
}
985
+
}
986
+
}
987
+
988
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
989
+
// The use of inline closures is to circumvent an issue where the compiler
990
+
// allocates stack space for every if/case branch local when no optimizations
991
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
992
+
// https://github.com/apple/swift-protobuf/issues/1182
993
+
if !self.id.isEmpty {
994
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
995
+
}
996
+
if !self.name.isEmpty {
997
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
998
+
}
999
+
try { if let v = self._description_p {
1000
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
1001
+
} }()
1002
+
try { if let v = self._image {
1003
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
1004
+
} }()
1005
+
try { if let v = self._folderID {
1006
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
1007
+
} }()
1008
+
try unknownFields.traverse(visitor: &visitor)
1009
+
}
1010
+
1011
+
static func ==(lhs: Rockbox_V1alpha1_UpdateSavedPlaylistRequest, rhs: Rockbox_V1alpha1_UpdateSavedPlaylistRequest) -> Bool {
1012
+
if lhs.id != rhs.id {return false}
1013
+
if lhs.name != rhs.name {return false}
1014
+
if lhs._description_p != rhs._description_p {return false}
1015
+
if lhs._image != rhs._image {return false}
1016
+
if lhs._folderID != rhs._folderID {return false}
1017
+
if lhs.unknownFields != rhs.unknownFields {return false}
1018
+
return true
1019
+
}
1020
+
}
1021
+
1022
+
extension Rockbox_V1alpha1_UpdateSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1023
+
static let protoMessageName: String = _protobuf_package + ".UpdateSavedPlaylistResponse"
1024
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1025
+
1026
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1027
+
// Load everything into unknown fields
1028
+
while try decoder.nextFieldNumber() != nil {}
1029
+
}
1030
+
1031
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1032
+
try unknownFields.traverse(visitor: &visitor)
1033
+
}
1034
+
1035
+
static func ==(lhs: Rockbox_V1alpha1_UpdateSavedPlaylistResponse, rhs: Rockbox_V1alpha1_UpdateSavedPlaylistResponse) -> Bool {
1036
+
if lhs.unknownFields != rhs.unknownFields {return false}
1037
+
return true
1038
+
}
1039
+
}
1040
+
1041
+
extension Rockbox_V1alpha1_DeleteSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1042
+
static let protoMessageName: String = _protobuf_package + ".DeleteSavedPlaylistRequest"
1043
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
1044
+
1045
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1046
+
while let fieldNumber = try decoder.nextFieldNumber() {
1047
+
// The use of inline closures is to circumvent an issue where the compiler
1048
+
// allocates stack space for every case branch when no optimizations are
1049
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1050
+
switch fieldNumber {
1051
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
1052
+
default: break
1053
+
}
1054
+
}
1055
+
}
1056
+
1057
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1058
+
if !self.id.isEmpty {
1059
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
1060
+
}
1061
+
try unknownFields.traverse(visitor: &visitor)
1062
+
}
1063
+
1064
+
static func ==(lhs: Rockbox_V1alpha1_DeleteSavedPlaylistRequest, rhs: Rockbox_V1alpha1_DeleteSavedPlaylistRequest) -> Bool {
1065
+
if lhs.id != rhs.id {return false}
1066
+
if lhs.unknownFields != rhs.unknownFields {return false}
1067
+
return true
1068
+
}
1069
+
}
1070
+
1071
+
extension Rockbox_V1alpha1_DeleteSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1072
+
static let protoMessageName: String = _protobuf_package + ".DeleteSavedPlaylistResponse"
1073
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1074
+
1075
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1076
+
// Load everything into unknown fields
1077
+
while try decoder.nextFieldNumber() != nil {}
1078
+
}
1079
+
1080
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1081
+
try unknownFields.traverse(visitor: &visitor)
1082
+
}
1083
+
1084
+
static func ==(lhs: Rockbox_V1alpha1_DeleteSavedPlaylistResponse, rhs: Rockbox_V1alpha1_DeleteSavedPlaylistResponse) -> Bool {
1085
+
if lhs.unknownFields != rhs.unknownFields {return false}
1086
+
return true
1087
+
}
1088
+
}
1089
+
1090
+
extension Rockbox_V1alpha1_GetSavedPlaylistTracksRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1091
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistTracksRequest"
1092
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}playlist_id\0")
1093
+
1094
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1095
+
while let fieldNumber = try decoder.nextFieldNumber() {
1096
+
// The use of inline closures is to circumvent an issue where the compiler
1097
+
// allocates stack space for every case branch when no optimizations are
1098
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1099
+
switch fieldNumber {
1100
+
case 1: try { try decoder.decodeSingularStringField(value: &self.playlistID) }()
1101
+
default: break
1102
+
}
1103
+
}
1104
+
}
1105
+
1106
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1107
+
if !self.playlistID.isEmpty {
1108
+
try visitor.visitSingularStringField(value: self.playlistID, fieldNumber: 1)
1109
+
}
1110
+
try unknownFields.traverse(visitor: &visitor)
1111
+
}
1112
+
1113
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistTracksRequest, rhs: Rockbox_V1alpha1_GetSavedPlaylistTracksRequest) -> Bool {
1114
+
if lhs.playlistID != rhs.playlistID {return false}
1115
+
if lhs.unknownFields != rhs.unknownFields {return false}
1116
+
return true
1117
+
}
1118
+
}
1119
+
1120
+
extension Rockbox_V1alpha1_GetSavedPlaylistTracksResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1121
+
static let protoMessageName: String = _protobuf_package + ".GetSavedPlaylistTracksResponse"
1122
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_ids\0")
1123
+
1124
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1125
+
while let fieldNumber = try decoder.nextFieldNumber() {
1126
+
// The use of inline closures is to circumvent an issue where the compiler
1127
+
// allocates stack space for every case branch when no optimizations are
1128
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1129
+
switch fieldNumber {
1130
+
case 1: try { try decoder.decodeRepeatedStringField(value: &self.trackIDs) }()
1131
+
default: break
1132
+
}
1133
+
}
1134
+
}
1135
+
1136
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1137
+
if !self.trackIDs.isEmpty {
1138
+
try visitor.visitRepeatedStringField(value: self.trackIDs, fieldNumber: 1)
1139
+
}
1140
+
try unknownFields.traverse(visitor: &visitor)
1141
+
}
1142
+
1143
+
static func ==(lhs: Rockbox_V1alpha1_GetSavedPlaylistTracksResponse, rhs: Rockbox_V1alpha1_GetSavedPlaylistTracksResponse) -> Bool {
1144
+
if lhs.trackIDs != rhs.trackIDs {return false}
1145
+
if lhs.unknownFields != rhs.unknownFields {return false}
1146
+
return true
1147
+
}
1148
+
}
1149
+
1150
+
extension Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1151
+
static let protoMessageName: String = _protobuf_package + ".AddTracksToSavedPlaylistRequest"
1152
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}playlist_id\0\u{3}track_ids\0")
1153
+
1154
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1155
+
while let fieldNumber = try decoder.nextFieldNumber() {
1156
+
// The use of inline closures is to circumvent an issue where the compiler
1157
+
// allocates stack space for every case branch when no optimizations are
1158
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1159
+
switch fieldNumber {
1160
+
case 1: try { try decoder.decodeSingularStringField(value: &self.playlistID) }()
1161
+
case 2: try { try decoder.decodeRepeatedStringField(value: &self.trackIDs) }()
1162
+
default: break
1163
+
}
1164
+
}
1165
+
}
1166
+
1167
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1168
+
if !self.playlistID.isEmpty {
1169
+
try visitor.visitSingularStringField(value: self.playlistID, fieldNumber: 1)
1170
+
}
1171
+
if !self.trackIDs.isEmpty {
1172
+
try visitor.visitRepeatedStringField(value: self.trackIDs, fieldNumber: 2)
1173
+
}
1174
+
try unknownFields.traverse(visitor: &visitor)
1175
+
}
1176
+
1177
+
static func ==(lhs: Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest, rhs: Rockbox_V1alpha1_AddTracksToSavedPlaylistRequest) -> Bool {
1178
+
if lhs.playlistID != rhs.playlistID {return false}
1179
+
if lhs.trackIDs != rhs.trackIDs {return false}
1180
+
if lhs.unknownFields != rhs.unknownFields {return false}
1181
+
return true
1182
+
}
1183
+
}
1184
+
1185
+
extension Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1186
+
static let protoMessageName: String = _protobuf_package + ".AddTracksToSavedPlaylistResponse"
1187
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1188
+
1189
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1190
+
// Load everything into unknown fields
1191
+
while try decoder.nextFieldNumber() != nil {}
1192
+
}
1193
+
1194
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1195
+
try unknownFields.traverse(visitor: &visitor)
1196
+
}
1197
+
1198
+
static func ==(lhs: Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse, rhs: Rockbox_V1alpha1_AddTracksToSavedPlaylistResponse) -> Bool {
1199
+
if lhs.unknownFields != rhs.unknownFields {return false}
1200
+
return true
1201
+
}
1202
+
}
1203
+
1204
+
extension Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1205
+
static let protoMessageName: String = _protobuf_package + ".RemoveTrackFromSavedPlaylistRequest"
1206
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}playlist_id\0\u{3}track_id\0")
1207
+
1208
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1209
+
while let fieldNumber = try decoder.nextFieldNumber() {
1210
+
// The use of inline closures is to circumvent an issue where the compiler
1211
+
// allocates stack space for every case branch when no optimizations are
1212
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1213
+
switch fieldNumber {
1214
+
case 1: try { try decoder.decodeSingularStringField(value: &self.playlistID) }()
1215
+
case 2: try { try decoder.decodeSingularStringField(value: &self.trackID) }()
1216
+
default: break
1217
+
}
1218
+
}
1219
+
}
1220
+
1221
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1222
+
if !self.playlistID.isEmpty {
1223
+
try visitor.visitSingularStringField(value: self.playlistID, fieldNumber: 1)
1224
+
}
1225
+
if !self.trackID.isEmpty {
1226
+
try visitor.visitSingularStringField(value: self.trackID, fieldNumber: 2)
1227
+
}
1228
+
try unknownFields.traverse(visitor: &visitor)
1229
+
}
1230
+
1231
+
static func ==(lhs: Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest, rhs: Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistRequest) -> Bool {
1232
+
if lhs.playlistID != rhs.playlistID {return false}
1233
+
if lhs.trackID != rhs.trackID {return false}
1234
+
if lhs.unknownFields != rhs.unknownFields {return false}
1235
+
return true
1236
+
}
1237
+
}
1238
+
1239
+
extension Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1240
+
static let protoMessageName: String = _protobuf_package + ".RemoveTrackFromSavedPlaylistResponse"
1241
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1242
+
1243
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1244
+
// Load everything into unknown fields
1245
+
while try decoder.nextFieldNumber() != nil {}
1246
+
}
1247
+
1248
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1249
+
try unknownFields.traverse(visitor: &visitor)
1250
+
}
1251
+
1252
+
static func ==(lhs: Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse, rhs: Rockbox_V1alpha1_RemoveTrackFromSavedPlaylistResponse) -> Bool {
1253
+
if lhs.unknownFields != rhs.unknownFields {return false}
1254
+
return true
1255
+
}
1256
+
}
1257
+
1258
+
extension Rockbox_V1alpha1_PlaySavedPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1259
+
static let protoMessageName: String = _protobuf_package + ".PlaySavedPlaylistRequest"
1260
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}playlist_id\0")
1261
+
1262
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1263
+
while let fieldNumber = try decoder.nextFieldNumber() {
1264
+
// The use of inline closures is to circumvent an issue where the compiler
1265
+
// allocates stack space for every case branch when no optimizations are
1266
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1267
+
switch fieldNumber {
1268
+
case 1: try { try decoder.decodeSingularStringField(value: &self.playlistID) }()
1269
+
default: break
1270
+
}
1271
+
}
1272
+
}
1273
+
1274
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1275
+
if !self.playlistID.isEmpty {
1276
+
try visitor.visitSingularStringField(value: self.playlistID, fieldNumber: 1)
1277
+
}
1278
+
try unknownFields.traverse(visitor: &visitor)
1279
+
}
1280
+
1281
+
static func ==(lhs: Rockbox_V1alpha1_PlaySavedPlaylistRequest, rhs: Rockbox_V1alpha1_PlaySavedPlaylistRequest) -> Bool {
1282
+
if lhs.playlistID != rhs.playlistID {return false}
1283
+
if lhs.unknownFields != rhs.unknownFields {return false}
1284
+
return true
1285
+
}
1286
+
}
1287
+
1288
+
extension Rockbox_V1alpha1_PlaySavedPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1289
+
static let protoMessageName: String = _protobuf_package + ".PlaySavedPlaylistResponse"
1290
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1291
+
1292
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1293
+
// Load everything into unknown fields
1294
+
while try decoder.nextFieldNumber() != nil {}
1295
+
}
1296
+
1297
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1298
+
try unknownFields.traverse(visitor: &visitor)
1299
+
}
1300
+
1301
+
static func ==(lhs: Rockbox_V1alpha1_PlaySavedPlaylistResponse, rhs: Rockbox_V1alpha1_PlaySavedPlaylistResponse) -> Bool {
1302
+
if lhs.unknownFields != rhs.unknownFields {return false}
1303
+
return true
1304
+
}
1305
+
}
+822
macos/Rockbox/Services/rockbox/v1alpha1/smart_playlist.grpc.swift
+822
macos/Rockbox/Services/rockbox/v1alpha1/smart_playlist.grpc.swift
···
1
+
// DO NOT EDIT.
2
+
// swift-format-ignore-file
3
+
// swiftlint:disable all
4
+
//
5
+
// Generated by the gRPC Swift generator plugin for the protocol buffer compiler.
6
+
// Source: rockbox/v1alpha1/smart_playlist.proto
7
+
//
8
+
// For information on using the generated types, please see the documentation:
9
+
// https://github.com/grpc/grpc-swift
10
+
11
+
import GRPCCore
12
+
import GRPCProtobuf
13
+
14
+
// MARK: - rockbox.v1alpha1.SmartPlaylistService
15
+
16
+
/// Namespace containing generated types for the "rockbox.v1alpha1.SmartPlaylistService" service.
17
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
18
+
internal enum Rockbox_V1alpha1_SmartPlaylistService: Sendable {
19
+
/// Service descriptor for the "rockbox.v1alpha1.SmartPlaylistService" service.
20
+
internal static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService")
21
+
/// Namespace for method metadata.
22
+
internal enum Method: Sendable {
23
+
/// Namespace for "GetSmartPlaylists" metadata.
24
+
internal enum GetSmartPlaylists: Sendable {
25
+
/// Request type for "GetSmartPlaylists".
26
+
internal typealias Input = Rockbox_V1alpha1_GetSmartPlaylistsRequest
27
+
/// Response type for "GetSmartPlaylists".
28
+
internal typealias Output = Rockbox_V1alpha1_GetSmartPlaylistsResponse
29
+
/// Descriptor for "GetSmartPlaylists".
30
+
internal static let descriptor = GRPCCore.MethodDescriptor(
31
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
32
+
method: "GetSmartPlaylists"
33
+
)
34
+
}
35
+
/// Namespace for "GetSmartPlaylist" metadata.
36
+
internal enum GetSmartPlaylist: Sendable {
37
+
/// Request type for "GetSmartPlaylist".
38
+
internal typealias Input = Rockbox_V1alpha1_GetSmartPlaylistRequest
39
+
/// Response type for "GetSmartPlaylist".
40
+
internal typealias Output = Rockbox_V1alpha1_GetSmartPlaylistResponse
41
+
/// Descriptor for "GetSmartPlaylist".
42
+
internal static let descriptor = GRPCCore.MethodDescriptor(
43
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
44
+
method: "GetSmartPlaylist"
45
+
)
46
+
}
47
+
/// Namespace for "CreateSmartPlaylist" metadata.
48
+
internal enum CreateSmartPlaylist: Sendable {
49
+
/// Request type for "CreateSmartPlaylist".
50
+
internal typealias Input = Rockbox_V1alpha1_CreateSmartPlaylistRequest
51
+
/// Response type for "CreateSmartPlaylist".
52
+
internal typealias Output = Rockbox_V1alpha1_CreateSmartPlaylistResponse
53
+
/// Descriptor for "CreateSmartPlaylist".
54
+
internal static let descriptor = GRPCCore.MethodDescriptor(
55
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
56
+
method: "CreateSmartPlaylist"
57
+
)
58
+
}
59
+
/// Namespace for "UpdateSmartPlaylist" metadata.
60
+
internal enum UpdateSmartPlaylist: Sendable {
61
+
/// Request type for "UpdateSmartPlaylist".
62
+
internal typealias Input = Rockbox_V1alpha1_UpdateSmartPlaylistRequest
63
+
/// Response type for "UpdateSmartPlaylist".
64
+
internal typealias Output = Rockbox_V1alpha1_UpdateSmartPlaylistResponse
65
+
/// Descriptor for "UpdateSmartPlaylist".
66
+
internal static let descriptor = GRPCCore.MethodDescriptor(
67
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
68
+
method: "UpdateSmartPlaylist"
69
+
)
70
+
}
71
+
/// Namespace for "DeleteSmartPlaylist" metadata.
72
+
internal enum DeleteSmartPlaylist: Sendable {
73
+
/// Request type for "DeleteSmartPlaylist".
74
+
internal typealias Input = Rockbox_V1alpha1_DeleteSmartPlaylistRequest
75
+
/// Response type for "DeleteSmartPlaylist".
76
+
internal typealias Output = Rockbox_V1alpha1_DeleteSmartPlaylistResponse
77
+
/// Descriptor for "DeleteSmartPlaylist".
78
+
internal static let descriptor = GRPCCore.MethodDescriptor(
79
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
80
+
method: "DeleteSmartPlaylist"
81
+
)
82
+
}
83
+
/// Namespace for "GetSmartPlaylistTracks" metadata.
84
+
internal enum GetSmartPlaylistTracks: Sendable {
85
+
/// Request type for "GetSmartPlaylistTracks".
86
+
internal typealias Input = Rockbox_V1alpha1_GetSmartPlaylistTracksRequest
87
+
/// Response type for "GetSmartPlaylistTracks".
88
+
internal typealias Output = Rockbox_V1alpha1_GetSmartPlaylistTracksResponse
89
+
/// Descriptor for "GetSmartPlaylistTracks".
90
+
internal static let descriptor = GRPCCore.MethodDescriptor(
91
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
92
+
method: "GetSmartPlaylistTracks"
93
+
)
94
+
}
95
+
/// Namespace for "PlaySmartPlaylist" metadata.
96
+
internal enum PlaySmartPlaylist: Sendable {
97
+
/// Request type for "PlaySmartPlaylist".
98
+
internal typealias Input = Rockbox_V1alpha1_PlaySmartPlaylistRequest
99
+
/// Response type for "PlaySmartPlaylist".
100
+
internal typealias Output = Rockbox_V1alpha1_PlaySmartPlaylistResponse
101
+
/// Descriptor for "PlaySmartPlaylist".
102
+
internal static let descriptor = GRPCCore.MethodDescriptor(
103
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
104
+
method: "PlaySmartPlaylist"
105
+
)
106
+
}
107
+
/// Namespace for "RecordTrackPlayed" metadata.
108
+
internal enum RecordTrackPlayed: Sendable {
109
+
/// Request type for "RecordTrackPlayed".
110
+
internal typealias Input = Rockbox_V1alpha1_RecordTrackPlayedRequest
111
+
/// Response type for "RecordTrackPlayed".
112
+
internal typealias Output = Rockbox_V1alpha1_RecordTrackPlayedResponse
113
+
/// Descriptor for "RecordTrackPlayed".
114
+
internal static let descriptor = GRPCCore.MethodDescriptor(
115
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
116
+
method: "RecordTrackPlayed"
117
+
)
118
+
}
119
+
/// Namespace for "RecordTrackSkipped" metadata.
120
+
internal enum RecordTrackSkipped: Sendable {
121
+
/// Request type for "RecordTrackSkipped".
122
+
internal typealias Input = Rockbox_V1alpha1_RecordTrackSkippedRequest
123
+
/// Response type for "RecordTrackSkipped".
124
+
internal typealias Output = Rockbox_V1alpha1_RecordTrackSkippedResponse
125
+
/// Descriptor for "RecordTrackSkipped".
126
+
internal static let descriptor = GRPCCore.MethodDescriptor(
127
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
128
+
method: "RecordTrackSkipped"
129
+
)
130
+
}
131
+
/// Namespace for "GetTrackStats" metadata.
132
+
internal enum GetTrackStats: Sendable {
133
+
/// Request type for "GetTrackStats".
134
+
internal typealias Input = Rockbox_V1alpha1_GetTrackStatsRequest
135
+
/// Response type for "GetTrackStats".
136
+
internal typealias Output = Rockbox_V1alpha1_GetTrackStatsResponse
137
+
/// Descriptor for "GetTrackStats".
138
+
internal static let descriptor = GRPCCore.MethodDescriptor(
139
+
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService"),
140
+
method: "GetTrackStats"
141
+
)
142
+
}
143
+
/// Descriptors for all methods in the "rockbox.v1alpha1.SmartPlaylistService" service.
144
+
internal static let descriptors: [GRPCCore.MethodDescriptor] = [
145
+
GetSmartPlaylists.descriptor,
146
+
GetSmartPlaylist.descriptor,
147
+
CreateSmartPlaylist.descriptor,
148
+
UpdateSmartPlaylist.descriptor,
149
+
DeleteSmartPlaylist.descriptor,
150
+
GetSmartPlaylistTracks.descriptor,
151
+
PlaySmartPlaylist.descriptor,
152
+
RecordTrackPlayed.descriptor,
153
+
RecordTrackSkipped.descriptor,
154
+
GetTrackStats.descriptor
155
+
]
156
+
}
157
+
}
158
+
159
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
160
+
extension GRPCCore.ServiceDescriptor {
161
+
/// Service descriptor for the "rockbox.v1alpha1.SmartPlaylistService" service.
162
+
internal static let rockbox_v1Alpha1_SmartPlaylistService = GRPCCore.ServiceDescriptor(fullyQualifiedService: "rockbox.v1alpha1.SmartPlaylistService")
163
+
}
164
+
165
+
// MARK: rockbox.v1alpha1.SmartPlaylistService (client)
166
+
167
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
168
+
extension Rockbox_V1alpha1_SmartPlaylistService {
169
+
/// Generated client protocol for the "rockbox.v1alpha1.SmartPlaylistService" service.
170
+
///
171
+
/// You don't need to implement this protocol directly, use the generated
172
+
/// implementation, ``Client``.
173
+
internal protocol ClientProtocol: Sendable {
174
+
/// Call the "GetSmartPlaylists" method.
175
+
func getSmartPlaylists<Result>(
176
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistsRequest>,
177
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistsRequest>,
178
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistsResponse>,
179
+
options: GRPCCore.CallOptions,
180
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistsResponse>) async throws -> Result
181
+
) async throws -> Result where Result: Sendable
182
+
183
+
/// Call the "GetSmartPlaylist" method.
184
+
func getSmartPlaylist<Result>(
185
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistRequest>,
186
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistRequest>,
187
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistResponse>,
188
+
options: GRPCCore.CallOptions,
189
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistResponse>) async throws -> Result
190
+
) async throws -> Result where Result: Sendable
191
+
192
+
/// Call the "CreateSmartPlaylist" method.
193
+
func createSmartPlaylist<Result>(
194
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSmartPlaylistRequest>,
195
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreateSmartPlaylistRequest>,
196
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreateSmartPlaylistResponse>,
197
+
options: GRPCCore.CallOptions,
198
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSmartPlaylistResponse>) async throws -> Result
199
+
) async throws -> Result where Result: Sendable
200
+
201
+
/// Call the "UpdateSmartPlaylist" method.
202
+
func updateSmartPlaylist<Result>(
203
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>,
204
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>,
205
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>,
206
+
options: GRPCCore.CallOptions,
207
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>) async throws -> Result
208
+
) async throws -> Result where Result: Sendable
209
+
210
+
/// Call the "DeleteSmartPlaylist" method.
211
+
func deleteSmartPlaylist<Result>(
212
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>,
213
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>,
214
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>,
215
+
options: GRPCCore.CallOptions,
216
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>) async throws -> Result
217
+
) async throws -> Result where Result: Sendable
218
+
219
+
/// Call the "GetSmartPlaylistTracks" method.
220
+
func getSmartPlaylistTracks<Result>(
221
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>,
222
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>,
223
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>,
224
+
options: GRPCCore.CallOptions,
225
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>) async throws -> Result
226
+
) async throws -> Result where Result: Sendable
227
+
228
+
/// Call the "PlaySmartPlaylist" method.
229
+
func playSmartPlaylist<Result>(
230
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySmartPlaylistRequest>,
231
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_PlaySmartPlaylistRequest>,
232
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_PlaySmartPlaylistResponse>,
233
+
options: GRPCCore.CallOptions,
234
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySmartPlaylistResponse>) async throws -> Result
235
+
) async throws -> Result where Result: Sendable
236
+
237
+
/// Call the "RecordTrackPlayed" method.
238
+
func recordTrackPlayed<Result>(
239
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackPlayedRequest>,
240
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RecordTrackPlayedRequest>,
241
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RecordTrackPlayedResponse>,
242
+
options: GRPCCore.CallOptions,
243
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackPlayedResponse>) async throws -> Result
244
+
) async throws -> Result where Result: Sendable
245
+
246
+
/// Call the "RecordTrackSkipped" method.
247
+
func recordTrackSkipped<Result>(
248
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackSkippedRequest>,
249
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RecordTrackSkippedRequest>,
250
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RecordTrackSkippedResponse>,
251
+
options: GRPCCore.CallOptions,
252
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackSkippedResponse>) async throws -> Result
253
+
) async throws -> Result where Result: Sendable
254
+
255
+
/// Call the "GetTrackStats" method.
256
+
func getTrackStats<Result>(
257
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetTrackStatsRequest>,
258
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetTrackStatsRequest>,
259
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetTrackStatsResponse>,
260
+
options: GRPCCore.CallOptions,
261
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetTrackStatsResponse>) async throws -> Result
262
+
) async throws -> Result where Result: Sendable
263
+
}
264
+
265
+
/// Generated client for the "rockbox.v1alpha1.SmartPlaylistService" service.
266
+
internal struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
267
+
private let client: GRPCCore.GRPCClient<Transport>
268
+
269
+
/// Creates a new client wrapping the provided `GRPCCore.GRPCClient`.
270
+
internal init(wrapping client: GRPCCore.GRPCClient<Transport>) {
271
+
self.client = client
272
+
}
273
+
274
+
internal func getSmartPlaylists<Result>(
275
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistsRequest>,
276
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistsRequest>,
277
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistsResponse>,
278
+
options: GRPCCore.CallOptions = .defaults,
279
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistsResponse>) async throws -> Result = { response in
280
+
try response.message
281
+
}
282
+
) async throws -> Result where Result: Sendable {
283
+
try await self.client.unary(
284
+
request: request,
285
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.GetSmartPlaylists.descriptor,
286
+
serializer: serializer,
287
+
deserializer: deserializer,
288
+
options: options,
289
+
onResponse: handleResponse
290
+
)
291
+
}
292
+
293
+
internal func getSmartPlaylist<Result>(
294
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistRequest>,
295
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistRequest>,
296
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistResponse>,
297
+
options: GRPCCore.CallOptions = .defaults,
298
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistResponse>) async throws -> Result = { response in
299
+
try response.message
300
+
}
301
+
) async throws -> Result where Result: Sendable {
302
+
try await self.client.unary(
303
+
request: request,
304
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.GetSmartPlaylist.descriptor,
305
+
serializer: serializer,
306
+
deserializer: deserializer,
307
+
options: options,
308
+
onResponse: handleResponse
309
+
)
310
+
}
311
+
312
+
internal func createSmartPlaylist<Result>(
313
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSmartPlaylistRequest>,
314
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_CreateSmartPlaylistRequest>,
315
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_CreateSmartPlaylistResponse>,
316
+
options: GRPCCore.CallOptions = .defaults,
317
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSmartPlaylistResponse>) async throws -> Result = { response in
318
+
try response.message
319
+
}
320
+
) async throws -> Result where Result: Sendable {
321
+
try await self.client.unary(
322
+
request: request,
323
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.CreateSmartPlaylist.descriptor,
324
+
serializer: serializer,
325
+
deserializer: deserializer,
326
+
options: options,
327
+
onResponse: handleResponse
328
+
)
329
+
}
330
+
331
+
internal func updateSmartPlaylist<Result>(
332
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>,
333
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>,
334
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>,
335
+
options: GRPCCore.CallOptions = .defaults,
336
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>) async throws -> Result = { response in
337
+
try response.message
338
+
}
339
+
) async throws -> Result where Result: Sendable {
340
+
try await self.client.unary(
341
+
request: request,
342
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.UpdateSmartPlaylist.descriptor,
343
+
serializer: serializer,
344
+
deserializer: deserializer,
345
+
options: options,
346
+
onResponse: handleResponse
347
+
)
348
+
}
349
+
350
+
internal func deleteSmartPlaylist<Result>(
351
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>,
352
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>,
353
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>,
354
+
options: GRPCCore.CallOptions = .defaults,
355
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>) async throws -> Result = { response in
356
+
try response.message
357
+
}
358
+
) async throws -> Result where Result: Sendable {
359
+
try await self.client.unary(
360
+
request: request,
361
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.DeleteSmartPlaylist.descriptor,
362
+
serializer: serializer,
363
+
deserializer: deserializer,
364
+
options: options,
365
+
onResponse: handleResponse
366
+
)
367
+
}
368
+
369
+
internal func getSmartPlaylistTracks<Result>(
370
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>,
371
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>,
372
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>,
373
+
options: GRPCCore.CallOptions = .defaults,
374
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>) async throws -> Result = { response in
375
+
try response.message
376
+
}
377
+
) async throws -> Result where Result: Sendable {
378
+
try await self.client.unary(
379
+
request: request,
380
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.GetSmartPlaylistTracks.descriptor,
381
+
serializer: serializer,
382
+
deserializer: deserializer,
383
+
options: options,
384
+
onResponse: handleResponse
385
+
)
386
+
}
387
+
388
+
internal func playSmartPlaylist<Result>(
389
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySmartPlaylistRequest>,
390
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_PlaySmartPlaylistRequest>,
391
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_PlaySmartPlaylistResponse>,
392
+
options: GRPCCore.CallOptions = .defaults,
393
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySmartPlaylistResponse>) async throws -> Result = { response in
394
+
try response.message
395
+
}
396
+
) async throws -> Result where Result: Sendable {
397
+
try await self.client.unary(
398
+
request: request,
399
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.PlaySmartPlaylist.descriptor,
400
+
serializer: serializer,
401
+
deserializer: deserializer,
402
+
options: options,
403
+
onResponse: handleResponse
404
+
)
405
+
}
406
+
407
+
internal func recordTrackPlayed<Result>(
408
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackPlayedRequest>,
409
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RecordTrackPlayedRequest>,
410
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RecordTrackPlayedResponse>,
411
+
options: GRPCCore.CallOptions = .defaults,
412
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackPlayedResponse>) async throws -> Result = { response in
413
+
try response.message
414
+
}
415
+
) async throws -> Result where Result: Sendable {
416
+
try await self.client.unary(
417
+
request: request,
418
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.RecordTrackPlayed.descriptor,
419
+
serializer: serializer,
420
+
deserializer: deserializer,
421
+
options: options,
422
+
onResponse: handleResponse
423
+
)
424
+
}
425
+
426
+
internal func recordTrackSkipped<Result>(
427
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackSkippedRequest>,
428
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_RecordTrackSkippedRequest>,
429
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_RecordTrackSkippedResponse>,
430
+
options: GRPCCore.CallOptions = .defaults,
431
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackSkippedResponse>) async throws -> Result = { response in
432
+
try response.message
433
+
}
434
+
) async throws -> Result where Result: Sendable {
435
+
try await self.client.unary(
436
+
request: request,
437
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.RecordTrackSkipped.descriptor,
438
+
serializer: serializer,
439
+
deserializer: deserializer,
440
+
options: options,
441
+
onResponse: handleResponse
442
+
)
443
+
}
444
+
445
+
internal func getTrackStats<Result>(
446
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetTrackStatsRequest>,
447
+
serializer: some GRPCCore.MessageSerializer<Rockbox_V1alpha1_GetTrackStatsRequest>,
448
+
deserializer: some GRPCCore.MessageDeserializer<Rockbox_V1alpha1_GetTrackStatsResponse>,
449
+
options: GRPCCore.CallOptions = .defaults,
450
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetTrackStatsResponse>) async throws -> Result = { response in
451
+
try response.message
452
+
}
453
+
) async throws -> Result where Result: Sendable {
454
+
try await self.client.unary(
455
+
request: request,
456
+
descriptor: Rockbox_V1alpha1_SmartPlaylistService.Method.GetTrackStats.descriptor,
457
+
serializer: serializer,
458
+
deserializer: deserializer,
459
+
options: options,
460
+
onResponse: handleResponse
461
+
)
462
+
}
463
+
}
464
+
}
465
+
466
+
// Helpers providing default arguments to 'ClientProtocol' methods.
467
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
468
+
extension Rockbox_V1alpha1_SmartPlaylistService.ClientProtocol {
469
+
internal func getSmartPlaylists<Result>(
470
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistsRequest>,
471
+
options: GRPCCore.CallOptions = .defaults,
472
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistsResponse>) async throws -> Result = { response in
473
+
try response.message
474
+
}
475
+
) async throws -> Result where Result: Sendable {
476
+
try await self.getSmartPlaylists(
477
+
request: request,
478
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSmartPlaylistsRequest>(),
479
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSmartPlaylistsResponse>(),
480
+
options: options,
481
+
onResponse: handleResponse
482
+
)
483
+
}
484
+
485
+
internal func getSmartPlaylist<Result>(
486
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistRequest>,
487
+
options: GRPCCore.CallOptions = .defaults,
488
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistResponse>) async throws -> Result = { response in
489
+
try response.message
490
+
}
491
+
) async throws -> Result where Result: Sendable {
492
+
try await self.getSmartPlaylist(
493
+
request: request,
494
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSmartPlaylistRequest>(),
495
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSmartPlaylistResponse>(),
496
+
options: options,
497
+
onResponse: handleResponse
498
+
)
499
+
}
500
+
501
+
internal func createSmartPlaylist<Result>(
502
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSmartPlaylistRequest>,
503
+
options: GRPCCore.CallOptions = .defaults,
504
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSmartPlaylistResponse>) async throws -> Result = { response in
505
+
try response.message
506
+
}
507
+
) async throws -> Result where Result: Sendable {
508
+
try await self.createSmartPlaylist(
509
+
request: request,
510
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_CreateSmartPlaylistRequest>(),
511
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_CreateSmartPlaylistResponse>(),
512
+
options: options,
513
+
onResponse: handleResponse
514
+
)
515
+
}
516
+
517
+
internal func updateSmartPlaylist<Result>(
518
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>,
519
+
options: GRPCCore.CallOptions = .defaults,
520
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>) async throws -> Result = { response in
521
+
try response.message
522
+
}
523
+
) async throws -> Result where Result: Sendable {
524
+
try await self.updateSmartPlaylist(
525
+
request: request,
526
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>(),
527
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>(),
528
+
options: options,
529
+
onResponse: handleResponse
530
+
)
531
+
}
532
+
533
+
internal func deleteSmartPlaylist<Result>(
534
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>,
535
+
options: GRPCCore.CallOptions = .defaults,
536
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>) async throws -> Result = { response in
537
+
try response.message
538
+
}
539
+
) async throws -> Result where Result: Sendable {
540
+
try await self.deleteSmartPlaylist(
541
+
request: request,
542
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>(),
543
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>(),
544
+
options: options,
545
+
onResponse: handleResponse
546
+
)
547
+
}
548
+
549
+
internal func getSmartPlaylistTracks<Result>(
550
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>,
551
+
options: GRPCCore.CallOptions = .defaults,
552
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>) async throws -> Result = { response in
553
+
try response.message
554
+
}
555
+
) async throws -> Result where Result: Sendable {
556
+
try await self.getSmartPlaylistTracks(
557
+
request: request,
558
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>(),
559
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>(),
560
+
options: options,
561
+
onResponse: handleResponse
562
+
)
563
+
}
564
+
565
+
internal func playSmartPlaylist<Result>(
566
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySmartPlaylistRequest>,
567
+
options: GRPCCore.CallOptions = .defaults,
568
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySmartPlaylistResponse>) async throws -> Result = { response in
569
+
try response.message
570
+
}
571
+
) async throws -> Result where Result: Sendable {
572
+
try await self.playSmartPlaylist(
573
+
request: request,
574
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_PlaySmartPlaylistRequest>(),
575
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_PlaySmartPlaylistResponse>(),
576
+
options: options,
577
+
onResponse: handleResponse
578
+
)
579
+
}
580
+
581
+
internal func recordTrackPlayed<Result>(
582
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackPlayedRequest>,
583
+
options: GRPCCore.CallOptions = .defaults,
584
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackPlayedResponse>) async throws -> Result = { response in
585
+
try response.message
586
+
}
587
+
) async throws -> Result where Result: Sendable {
588
+
try await self.recordTrackPlayed(
589
+
request: request,
590
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_RecordTrackPlayedRequest>(),
591
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_RecordTrackPlayedResponse>(),
592
+
options: options,
593
+
onResponse: handleResponse
594
+
)
595
+
}
596
+
597
+
internal func recordTrackSkipped<Result>(
598
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackSkippedRequest>,
599
+
options: GRPCCore.CallOptions = .defaults,
600
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackSkippedResponse>) async throws -> Result = { response in
601
+
try response.message
602
+
}
603
+
) async throws -> Result where Result: Sendable {
604
+
try await self.recordTrackSkipped(
605
+
request: request,
606
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_RecordTrackSkippedRequest>(),
607
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_RecordTrackSkippedResponse>(),
608
+
options: options,
609
+
onResponse: handleResponse
610
+
)
611
+
}
612
+
613
+
internal func getTrackStats<Result>(
614
+
request: GRPCCore.ClientRequest<Rockbox_V1alpha1_GetTrackStatsRequest>,
615
+
options: GRPCCore.CallOptions = .defaults,
616
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetTrackStatsResponse>) async throws -> Result = { response in
617
+
try response.message
618
+
}
619
+
) async throws -> Result where Result: Sendable {
620
+
try await self.getTrackStats(
621
+
request: request,
622
+
serializer: GRPCProtobuf.ProtobufSerializer<Rockbox_V1alpha1_GetTrackStatsRequest>(),
623
+
deserializer: GRPCProtobuf.ProtobufDeserializer<Rockbox_V1alpha1_GetTrackStatsResponse>(),
624
+
options: options,
625
+
onResponse: handleResponse
626
+
)
627
+
}
628
+
}
629
+
630
+
// Helpers providing sugared APIs for 'ClientProtocol' methods.
631
+
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
632
+
extension Rockbox_V1alpha1_SmartPlaylistService.ClientProtocol {
633
+
internal func getSmartPlaylists<Result>(
634
+
_ message: Rockbox_V1alpha1_GetSmartPlaylistsRequest,
635
+
metadata: GRPCCore.Metadata = [:],
636
+
options: GRPCCore.CallOptions = .defaults,
637
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistsResponse>) async throws -> Result = { response in
638
+
try response.message
639
+
}
640
+
) async throws -> Result where Result: Sendable {
641
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistsRequest>(
642
+
message: message,
643
+
metadata: metadata
644
+
)
645
+
return try await self.getSmartPlaylists(
646
+
request: request,
647
+
options: options,
648
+
onResponse: handleResponse
649
+
)
650
+
}
651
+
652
+
internal func getSmartPlaylist<Result>(
653
+
_ message: Rockbox_V1alpha1_GetSmartPlaylistRequest,
654
+
metadata: GRPCCore.Metadata = [:],
655
+
options: GRPCCore.CallOptions = .defaults,
656
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistResponse>) async throws -> Result = { response in
657
+
try response.message
658
+
}
659
+
) async throws -> Result where Result: Sendable {
660
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistRequest>(
661
+
message: message,
662
+
metadata: metadata
663
+
)
664
+
return try await self.getSmartPlaylist(
665
+
request: request,
666
+
options: options,
667
+
onResponse: handleResponse
668
+
)
669
+
}
670
+
671
+
internal func createSmartPlaylist<Result>(
672
+
_ message: Rockbox_V1alpha1_CreateSmartPlaylistRequest,
673
+
metadata: GRPCCore.Metadata = [:],
674
+
options: GRPCCore.CallOptions = .defaults,
675
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_CreateSmartPlaylistResponse>) async throws -> Result = { response in
676
+
try response.message
677
+
}
678
+
) async throws -> Result where Result: Sendable {
679
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_CreateSmartPlaylistRequest>(
680
+
message: message,
681
+
metadata: metadata
682
+
)
683
+
return try await self.createSmartPlaylist(
684
+
request: request,
685
+
options: options,
686
+
onResponse: handleResponse
687
+
)
688
+
}
689
+
690
+
internal func updateSmartPlaylist<Result>(
691
+
_ message: Rockbox_V1alpha1_UpdateSmartPlaylistRequest,
692
+
metadata: GRPCCore.Metadata = [:],
693
+
options: GRPCCore.CallOptions = .defaults,
694
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_UpdateSmartPlaylistResponse>) async throws -> Result = { response in
695
+
try response.message
696
+
}
697
+
) async throws -> Result where Result: Sendable {
698
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_UpdateSmartPlaylistRequest>(
699
+
message: message,
700
+
metadata: metadata
701
+
)
702
+
return try await self.updateSmartPlaylist(
703
+
request: request,
704
+
options: options,
705
+
onResponse: handleResponse
706
+
)
707
+
}
708
+
709
+
internal func deleteSmartPlaylist<Result>(
710
+
_ message: Rockbox_V1alpha1_DeleteSmartPlaylistRequest,
711
+
metadata: GRPCCore.Metadata = [:],
712
+
options: GRPCCore.CallOptions = .defaults,
713
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_DeleteSmartPlaylistResponse>) async throws -> Result = { response in
714
+
try response.message
715
+
}
716
+
) async throws -> Result where Result: Sendable {
717
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_DeleteSmartPlaylistRequest>(
718
+
message: message,
719
+
metadata: metadata
720
+
)
721
+
return try await self.deleteSmartPlaylist(
722
+
request: request,
723
+
options: options,
724
+
onResponse: handleResponse
725
+
)
726
+
}
727
+
728
+
internal func getSmartPlaylistTracks<Result>(
729
+
_ message: Rockbox_V1alpha1_GetSmartPlaylistTracksRequest,
730
+
metadata: GRPCCore.Metadata = [:],
731
+
options: GRPCCore.CallOptions = .defaults,
732
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetSmartPlaylistTracksResponse>) async throws -> Result = { response in
733
+
try response.message
734
+
}
735
+
) async throws -> Result where Result: Sendable {
736
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetSmartPlaylistTracksRequest>(
737
+
message: message,
738
+
metadata: metadata
739
+
)
740
+
return try await self.getSmartPlaylistTracks(
741
+
request: request,
742
+
options: options,
743
+
onResponse: handleResponse
744
+
)
745
+
}
746
+
747
+
internal func playSmartPlaylist<Result>(
748
+
_ message: Rockbox_V1alpha1_PlaySmartPlaylistRequest,
749
+
metadata: GRPCCore.Metadata = [:],
750
+
options: GRPCCore.CallOptions = .defaults,
751
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_PlaySmartPlaylistResponse>) async throws -> Result = { response in
752
+
try response.message
753
+
}
754
+
) async throws -> Result where Result: Sendable {
755
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_PlaySmartPlaylistRequest>(
756
+
message: message,
757
+
metadata: metadata
758
+
)
759
+
return try await self.playSmartPlaylist(
760
+
request: request,
761
+
options: options,
762
+
onResponse: handleResponse
763
+
)
764
+
}
765
+
766
+
internal func recordTrackPlayed<Result>(
767
+
_ message: Rockbox_V1alpha1_RecordTrackPlayedRequest,
768
+
metadata: GRPCCore.Metadata = [:],
769
+
options: GRPCCore.CallOptions = .defaults,
770
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackPlayedResponse>) async throws -> Result = { response in
771
+
try response.message
772
+
}
773
+
) async throws -> Result where Result: Sendable {
774
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackPlayedRequest>(
775
+
message: message,
776
+
metadata: metadata
777
+
)
778
+
return try await self.recordTrackPlayed(
779
+
request: request,
780
+
options: options,
781
+
onResponse: handleResponse
782
+
)
783
+
}
784
+
785
+
internal func recordTrackSkipped<Result>(
786
+
_ message: Rockbox_V1alpha1_RecordTrackSkippedRequest,
787
+
metadata: GRPCCore.Metadata = [:],
788
+
options: GRPCCore.CallOptions = .defaults,
789
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_RecordTrackSkippedResponse>) async throws -> Result = { response in
790
+
try response.message
791
+
}
792
+
) async throws -> Result where Result: Sendable {
793
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_RecordTrackSkippedRequest>(
794
+
message: message,
795
+
metadata: metadata
796
+
)
797
+
return try await self.recordTrackSkipped(
798
+
request: request,
799
+
options: options,
800
+
onResponse: handleResponse
801
+
)
802
+
}
803
+
804
+
internal func getTrackStats<Result>(
805
+
_ message: Rockbox_V1alpha1_GetTrackStatsRequest,
806
+
metadata: GRPCCore.Metadata = [:],
807
+
options: GRPCCore.CallOptions = .defaults,
808
+
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Rockbox_V1alpha1_GetTrackStatsResponse>) async throws -> Result = { response in
809
+
try response.message
810
+
}
811
+
) async throws -> Result where Result: Sendable {
812
+
let request = GRPCCore.ClientRequest<Rockbox_V1alpha1_GetTrackStatsRequest>(
813
+
message: message,
814
+
metadata: metadata
815
+
)
816
+
return try await self.getTrackStats(
817
+
request: request,
818
+
options: options,
819
+
onResponse: handleResponse
820
+
)
821
+
}
822
+
}
+1500
macos/Rockbox/Services/rockbox/v1alpha1/smart_playlist.pb.swift
+1500
macos/Rockbox/Services/rockbox/v1alpha1/smart_playlist.pb.swift
···
1
+
// DO NOT EDIT.
2
+
// swift-format-ignore-file
3
+
// swiftlint:disable all
4
+
//
5
+
// Generated by the Swift generator plugin for the protocol buffer compiler.
6
+
// Source: rockbox/v1alpha1/smart_playlist.proto
7
+
//
8
+
// For information on using the generated types, please see the documentation:
9
+
// https://github.com/apple/swift-protobuf/
10
+
11
+
import SwiftProtobuf
12
+
13
+
// If the compiler emits an error on this type, it is because this file
14
+
// was generated by a version of the `protoc` Swift plug-in that is
15
+
// incompatible with the version of SwiftProtobuf to which you are linking.
16
+
// Please ensure that you are building against the same version of the API
17
+
// that was used to generate this file.
18
+
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
19
+
struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
20
+
typealias Version = _2
21
+
}
22
+
23
+
struct Rockbox_V1alpha1_RuleCondition: Sendable {
24
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
25
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
26
+
// methods supported on all messages.
27
+
28
+
var field: String = String()
29
+
30
+
/// `operator` is a Swift keyword; use `operator_p` as the property name.
31
+
var operator_p: String = String()
32
+
33
+
var value: String {
34
+
get {return _value ?? String()}
35
+
set {_value = newValue}
36
+
}
37
+
/// Returns true if `value` has been explicitly set.
38
+
var hasValue: Bool {return self._value != nil}
39
+
/// Clears the value of `value`. Subsequent reads from it will return its default value.
40
+
mutating func clearValue() {self._value = nil}
41
+
42
+
var value2: String {
43
+
get {return _value2 ?? String()}
44
+
set {_value2 = newValue}
45
+
}
46
+
/// Returns true if `value2` has been explicitly set.
47
+
var hasValue2: Bool {return self._value2 != nil}
48
+
/// Clears the value of `value2`. Subsequent reads from it will return its default value.
49
+
mutating func clearValue2() {self._value2 = nil}
50
+
51
+
var unit: String {
52
+
get {return _unit ?? String()}
53
+
set {_unit = newValue}
54
+
}
55
+
/// Returns true if `unit` has been explicitly set.
56
+
var hasUnit: Bool {return self._unit != nil}
57
+
/// Clears the value of `unit`. Subsequent reads from it will return its default value.
58
+
mutating func clearUnit() {self._unit = nil}
59
+
60
+
var unknownFields = SwiftProtobuf.UnknownStorage()
61
+
62
+
init() {}
63
+
64
+
fileprivate var _value: String? = nil
65
+
fileprivate var _value2: String? = nil
66
+
fileprivate var _unit: String? = nil
67
+
}
68
+
69
+
struct Rockbox_V1alpha1_RuleCriteria: Sendable {
70
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
71
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
72
+
// methods supported on all messages.
73
+
74
+
var matchType: String = String()
75
+
76
+
var conditions: [Rockbox_V1alpha1_RuleCondition] = []
77
+
78
+
var limit: Int32 {
79
+
get {return _limit ?? 0}
80
+
set {_limit = newValue}
81
+
}
82
+
/// Returns true if `limit` has been explicitly set.
83
+
var hasLimit: Bool {return self._limit != nil}
84
+
/// Clears the value of `limit`. Subsequent reads from it will return its default value.
85
+
mutating func clearLimit() {self._limit = nil}
86
+
87
+
var sortBy: String {
88
+
get {return _sortBy ?? String()}
89
+
set {_sortBy = newValue}
90
+
}
91
+
/// Returns true if `sortBy` has been explicitly set.
92
+
var hasSortBy: Bool {return self._sortBy != nil}
93
+
/// Clears the value of `sortBy`. Subsequent reads from it will return its default value.
94
+
mutating func clearSortBy() {self._sortBy = nil}
95
+
96
+
var sortOrder: String {
97
+
get {return _sortOrder ?? String()}
98
+
set {_sortOrder = newValue}
99
+
}
100
+
/// Returns true if `sortOrder` has been explicitly set.
101
+
var hasSortOrder: Bool {return self._sortOrder != nil}
102
+
/// Clears the value of `sortOrder`. Subsequent reads from it will return its default value.
103
+
mutating func clearSortOrder() {self._sortOrder = nil}
104
+
105
+
var unknownFields = SwiftProtobuf.UnknownStorage()
106
+
107
+
init() {}
108
+
109
+
fileprivate var _limit: Int32? = nil
110
+
fileprivate var _sortBy: String? = nil
111
+
fileprivate var _sortOrder: String? = nil
112
+
}
113
+
114
+
struct Rockbox_V1alpha1_SmartPlaylist: Sendable {
115
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
116
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
117
+
// methods supported on all messages.
118
+
119
+
var id: String = String()
120
+
121
+
var name: String = String()
122
+
123
+
var description_p: String {
124
+
get {return _storage._description_p ?? String()}
125
+
set {_uniqueStorage()._description_p = newValue}
126
+
}
127
+
/// Returns true if `description_p` has been explicitly set.
128
+
var hasDescription_p: Bool {return _storage._description_p != nil}
129
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
130
+
mutating func clearDescription_p() {_uniqueStorage()._description_p = nil}
131
+
132
+
var image: String {
133
+
get {return _storage._image ?? String()}
134
+
set {_uniqueStorage()._image = newValue}
135
+
}
136
+
/// Returns true if `image` has been explicitly set.
137
+
var hasImage: Bool {return _storage._image != nil}
138
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
139
+
mutating func clearImage() {_uniqueStorage()._image = nil}
140
+
141
+
var folderID: String {
142
+
get {return _storage._folderID ?? String()}
143
+
set {_uniqueStorage()._folderID = newValue}
144
+
}
145
+
/// Returns true if `folderID` has been explicitly set.
146
+
var hasFolderID: Bool {return _storage._folderID != nil}
147
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
148
+
mutating func clearFolderID() {_uniqueStorage()._folderID = nil}
149
+
150
+
var isSystem: Bool = false
151
+
152
+
var rules: Rockbox_V1alpha1_RuleCriteria {
153
+
get {return _storage._rules ?? Rockbox_V1alpha1_RuleCriteria()}
154
+
set {_uniqueStorage()._rules = newValue}
155
+
}
156
+
/// Returns true if `rules` has been explicitly set.
157
+
var hasRules: Bool {return _storage._rules != nil}
158
+
/// Clears the value of `rules`. Subsequent reads from it will return its default value.
159
+
mutating func clearRules() {_uniqueStorage()._rules = nil}
160
+
161
+
var createdAt: Int64 = 0
162
+
163
+
var updatedAt: Int64 = 0
164
+
165
+
var unknownFields = SwiftProtobuf.UnknownStorage()
166
+
167
+
init() {}
168
+
169
+
fileprivate var _storage = _StorageClass.defaultInstance
170
+
171
+
fileprivate final class _StorageClass {
172
+
var _description_p: String? = nil
173
+
var _image: String? = nil
174
+
var _folderID: String? = nil
175
+
var _rules: Rockbox_V1alpha1_RuleCriteria? = nil
176
+
177
+
static let defaultInstance = _StorageClass()
178
+
179
+
private init() {}
180
+
181
+
init(copying source: _StorageClass) {
182
+
_description_p = source._description_p
183
+
_image = source._image
184
+
_folderID = source._folderID
185
+
_rules = source._rules
186
+
}
187
+
}
188
+
189
+
fileprivate mutating func _uniqueStorage() -> _StorageClass {
190
+
if !isKnownUniquelyReferenced(&_storage) {
191
+
_storage = _StorageClass(copying: _storage)
192
+
}
193
+
return _storage
194
+
}
195
+
}
196
+
197
+
struct Rockbox_V1alpha1_GetSmartPlaylistsRequest: Sendable {
198
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
199
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
200
+
// methods supported on all messages.
201
+
202
+
var unknownFields = SwiftProtobuf.UnknownStorage()
203
+
204
+
init() {}
205
+
}
206
+
207
+
struct Rockbox_V1alpha1_GetSmartPlaylistsResponse: Sendable {
208
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
209
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
210
+
// methods supported on all messages.
211
+
212
+
var playlists: [Rockbox_V1alpha1_SmartPlaylist] = []
213
+
214
+
var unknownFields = SwiftProtobuf.UnknownStorage()
215
+
216
+
init() {}
217
+
}
218
+
219
+
struct Rockbox_V1alpha1_GetSmartPlaylistRequest: Sendable {
220
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
221
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
222
+
// methods supported on all messages.
223
+
224
+
var id: String = String()
225
+
226
+
var unknownFields = SwiftProtobuf.UnknownStorage()
227
+
228
+
init() {}
229
+
}
230
+
231
+
struct Rockbox_V1alpha1_GetSmartPlaylistResponse: Sendable {
232
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
233
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
234
+
// methods supported on all messages.
235
+
236
+
var playlist: Rockbox_V1alpha1_SmartPlaylist {
237
+
get {return _playlist ?? Rockbox_V1alpha1_SmartPlaylist()}
238
+
set {_playlist = newValue}
239
+
}
240
+
/// Returns true if `playlist` has been explicitly set.
241
+
var hasPlaylist: Bool {return self._playlist != nil}
242
+
/// Clears the value of `playlist`. Subsequent reads from it will return its default value.
243
+
mutating func clearPlaylist() {self._playlist = nil}
244
+
245
+
var unknownFields = SwiftProtobuf.UnknownStorage()
246
+
247
+
init() {}
248
+
249
+
fileprivate var _playlist: Rockbox_V1alpha1_SmartPlaylist? = nil
250
+
}
251
+
252
+
struct Rockbox_V1alpha1_CreateSmartPlaylistRequest: Sendable {
253
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
254
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
255
+
// methods supported on all messages.
256
+
257
+
var name: String = String()
258
+
259
+
var description_p: String {
260
+
get {return _storage._description_p ?? String()}
261
+
set {_uniqueStorage()._description_p = newValue}
262
+
}
263
+
/// Returns true if `description_p` has been explicitly set.
264
+
var hasDescription_p: Bool {return _storage._description_p != nil}
265
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
266
+
mutating func clearDescription_p() {_uniqueStorage()._description_p = nil}
267
+
268
+
var image: String {
269
+
get {return _storage._image ?? String()}
270
+
set {_uniqueStorage()._image = newValue}
271
+
}
272
+
/// Returns true if `image` has been explicitly set.
273
+
var hasImage: Bool {return _storage._image != nil}
274
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
275
+
mutating func clearImage() {_uniqueStorage()._image = nil}
276
+
277
+
var folderID: String {
278
+
get {return _storage._folderID ?? String()}
279
+
set {_uniqueStorage()._folderID = newValue}
280
+
}
281
+
/// Returns true if `folderID` has been explicitly set.
282
+
var hasFolderID: Bool {return _storage._folderID != nil}
283
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
284
+
mutating func clearFolderID() {_uniqueStorage()._folderID = nil}
285
+
286
+
var rules: Rockbox_V1alpha1_RuleCriteria {
287
+
get {return _storage._rules ?? Rockbox_V1alpha1_RuleCriteria()}
288
+
set {_uniqueStorage()._rules = newValue}
289
+
}
290
+
/// Returns true if `rules` has been explicitly set.
291
+
var hasRules: Bool {return _storage._rules != nil}
292
+
/// Clears the value of `rules`. Subsequent reads from it will return its default value.
293
+
mutating func clearRules() {_uniqueStorage()._rules = nil}
294
+
295
+
var unknownFields = SwiftProtobuf.UnknownStorage()
296
+
297
+
init() {}
298
+
299
+
fileprivate var _storage = _StorageClass.defaultInstance
300
+
301
+
fileprivate final class _StorageClass {
302
+
var _description_p: String? = nil
303
+
var _image: String? = nil
304
+
var _folderID: String? = nil
305
+
var _rules: Rockbox_V1alpha1_RuleCriteria? = nil
306
+
307
+
static let defaultInstance = _StorageClass()
308
+
309
+
private init() {}
310
+
311
+
init(copying source: _StorageClass) {
312
+
_description_p = source._description_p
313
+
_image = source._image
314
+
_folderID = source._folderID
315
+
_rules = source._rules
316
+
}
317
+
}
318
+
319
+
fileprivate mutating func _uniqueStorage() -> _StorageClass {
320
+
if !isKnownUniquelyReferenced(&_storage) {
321
+
_storage = _StorageClass(copying: _storage)
322
+
}
323
+
return _storage
324
+
}
325
+
}
326
+
327
+
struct Rockbox_V1alpha1_CreateSmartPlaylistResponse: Sendable {
328
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
329
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
330
+
// methods supported on all messages.
331
+
332
+
var playlist: Rockbox_V1alpha1_SmartPlaylist {
333
+
get {return _playlist ?? Rockbox_V1alpha1_SmartPlaylist()}
334
+
set {_playlist = newValue}
335
+
}
336
+
/// Returns true if `playlist` has been explicitly set.
337
+
var hasPlaylist: Bool {return self._playlist != nil}
338
+
/// Clears the value of `playlist`. Subsequent reads from it will return its default value.
339
+
mutating func clearPlaylist() {self._playlist = nil}
340
+
341
+
var unknownFields = SwiftProtobuf.UnknownStorage()
342
+
343
+
init() {}
344
+
345
+
fileprivate var _playlist: Rockbox_V1alpha1_SmartPlaylist? = nil
346
+
}
347
+
348
+
struct Rockbox_V1alpha1_UpdateSmartPlaylistRequest: Sendable {
349
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
350
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
351
+
// methods supported on all messages.
352
+
353
+
var id: String = String()
354
+
355
+
var name: String = String()
356
+
357
+
var description_p: String {
358
+
get {return _storage._description_p ?? String()}
359
+
set {_uniqueStorage()._description_p = newValue}
360
+
}
361
+
/// Returns true if `description_p` has been explicitly set.
362
+
var hasDescription_p: Bool {return _storage._description_p != nil}
363
+
/// Clears the value of `description_p`. Subsequent reads from it will return its default value.
364
+
mutating func clearDescription_p() {_uniqueStorage()._description_p = nil}
365
+
366
+
var image: String {
367
+
get {return _storage._image ?? String()}
368
+
set {_uniqueStorage()._image = newValue}
369
+
}
370
+
/// Returns true if `image` has been explicitly set.
371
+
var hasImage: Bool {return _storage._image != nil}
372
+
/// Clears the value of `image`. Subsequent reads from it will return its default value.
373
+
mutating func clearImage() {_uniqueStorage()._image = nil}
374
+
375
+
var folderID: String {
376
+
get {return _storage._folderID ?? String()}
377
+
set {_uniqueStorage()._folderID = newValue}
378
+
}
379
+
/// Returns true if `folderID` has been explicitly set.
380
+
var hasFolderID: Bool {return _storage._folderID != nil}
381
+
/// Clears the value of `folderID`. Subsequent reads from it will return its default value.
382
+
mutating func clearFolderID() {_uniqueStorage()._folderID = nil}
383
+
384
+
var rules: Rockbox_V1alpha1_RuleCriteria {
385
+
get {return _storage._rules ?? Rockbox_V1alpha1_RuleCriteria()}
386
+
set {_uniqueStorage()._rules = newValue}
387
+
}
388
+
/// Returns true if `rules` has been explicitly set.
389
+
var hasRules: Bool {return _storage._rules != nil}
390
+
/// Clears the value of `rules`. Subsequent reads from it will return its default value.
391
+
mutating func clearRules() {_uniqueStorage()._rules = nil}
392
+
393
+
var unknownFields = SwiftProtobuf.UnknownStorage()
394
+
395
+
init() {}
396
+
397
+
fileprivate var _storage = _StorageClass.defaultInstance
398
+
399
+
fileprivate final class _StorageClass {
400
+
var _description_p: String? = nil
401
+
var _image: String? = nil
402
+
var _folderID: String? = nil
403
+
var _rules: Rockbox_V1alpha1_RuleCriteria? = nil
404
+
405
+
static let defaultInstance = _StorageClass()
406
+
407
+
private init() {}
408
+
409
+
init(copying source: _StorageClass) {
410
+
_description_p = source._description_p
411
+
_image = source._image
412
+
_folderID = source._folderID
413
+
_rules = source._rules
414
+
}
415
+
}
416
+
417
+
fileprivate mutating func _uniqueStorage() -> _StorageClass {
418
+
if !isKnownUniquelyReferenced(&_storage) {
419
+
_storage = _StorageClass(copying: _storage)
420
+
}
421
+
return _storage
422
+
}
423
+
}
424
+
425
+
struct Rockbox_V1alpha1_UpdateSmartPlaylistResponse: Sendable {
426
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
427
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
428
+
// methods supported on all messages.
429
+
430
+
var unknownFields = SwiftProtobuf.UnknownStorage()
431
+
432
+
init() {}
433
+
}
434
+
435
+
struct Rockbox_V1alpha1_DeleteSmartPlaylistRequest: Sendable {
436
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
437
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
438
+
// methods supported on all messages.
439
+
440
+
var id: String = String()
441
+
442
+
var unknownFields = SwiftProtobuf.UnknownStorage()
443
+
444
+
init() {}
445
+
}
446
+
447
+
struct Rockbox_V1alpha1_DeleteSmartPlaylistResponse: Sendable {
448
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
449
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
450
+
// methods supported on all messages.
451
+
452
+
var unknownFields = SwiftProtobuf.UnknownStorage()
453
+
454
+
init() {}
455
+
}
456
+
457
+
struct Rockbox_V1alpha1_GetSmartPlaylistTracksRequest: Sendable {
458
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
459
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
460
+
// methods supported on all messages.
461
+
462
+
var id: String = String()
463
+
464
+
var unknownFields = SwiftProtobuf.UnknownStorage()
465
+
466
+
init() {}
467
+
}
468
+
469
+
struct Rockbox_V1alpha1_GetSmartPlaylistTracksResponse: Sendable {
470
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
471
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
472
+
// methods supported on all messages.
473
+
474
+
var trackIDs: [String] = []
475
+
476
+
var unknownFields = SwiftProtobuf.UnknownStorage()
477
+
478
+
init() {}
479
+
}
480
+
481
+
struct Rockbox_V1alpha1_PlaySmartPlaylistRequest: Sendable {
482
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
483
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
484
+
// methods supported on all messages.
485
+
486
+
var id: String = String()
487
+
488
+
var unknownFields = SwiftProtobuf.UnknownStorage()
489
+
490
+
init() {}
491
+
}
492
+
493
+
struct Rockbox_V1alpha1_PlaySmartPlaylistResponse: Sendable {
494
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
495
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
496
+
// methods supported on all messages.
497
+
498
+
var unknownFields = SwiftProtobuf.UnknownStorage()
499
+
500
+
init() {}
501
+
}
502
+
503
+
struct Rockbox_V1alpha1_TrackStats: Sendable {
504
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
505
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
506
+
// methods supported on all messages.
507
+
508
+
var trackID: String = String()
509
+
510
+
var playCount: Int64 = 0
511
+
512
+
var skipCount: Int64 = 0
513
+
514
+
var lastPlayed: Int64 {
515
+
get {return _lastPlayed ?? 0}
516
+
set {_lastPlayed = newValue}
517
+
}
518
+
/// Returns true if `lastPlayed` has been explicitly set.
519
+
var hasLastPlayed: Bool {return self._lastPlayed != nil}
520
+
/// Clears the value of `lastPlayed`. Subsequent reads from it will return its default value.
521
+
mutating func clearLastPlayed() {self._lastPlayed = nil}
522
+
523
+
var lastSkipped: Int64 {
524
+
get {return _lastSkipped ?? 0}
525
+
set {_lastSkipped = newValue}
526
+
}
527
+
/// Returns true if `lastSkipped` has been explicitly set.
528
+
var hasLastSkipped: Bool {return self._lastSkipped != nil}
529
+
/// Clears the value of `lastSkipped`. Subsequent reads from it will return its default value.
530
+
mutating func clearLastSkipped() {self._lastSkipped = nil}
531
+
532
+
var updatedAt: Int64 = 0
533
+
534
+
var unknownFields = SwiftProtobuf.UnknownStorage()
535
+
536
+
init() {}
537
+
538
+
fileprivate var _lastPlayed: Int64? = nil
539
+
fileprivate var _lastSkipped: Int64? = nil
540
+
}
541
+
542
+
struct Rockbox_V1alpha1_RecordTrackPlayedRequest: Sendable {
543
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
544
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
545
+
// methods supported on all messages.
546
+
547
+
var trackID: String = String()
548
+
549
+
var unknownFields = SwiftProtobuf.UnknownStorage()
550
+
551
+
init() {}
552
+
}
553
+
554
+
struct Rockbox_V1alpha1_RecordTrackPlayedResponse: Sendable {
555
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
556
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
557
+
// methods supported on all messages.
558
+
559
+
var unknownFields = SwiftProtobuf.UnknownStorage()
560
+
561
+
init() {}
562
+
}
563
+
564
+
struct Rockbox_V1alpha1_RecordTrackSkippedRequest: Sendable {
565
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
566
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
567
+
// methods supported on all messages.
568
+
569
+
var trackID: String = String()
570
+
571
+
var unknownFields = SwiftProtobuf.UnknownStorage()
572
+
573
+
init() {}
574
+
}
575
+
576
+
struct Rockbox_V1alpha1_RecordTrackSkippedResponse: Sendable {
577
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
578
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
579
+
// methods supported on all messages.
580
+
581
+
var unknownFields = SwiftProtobuf.UnknownStorage()
582
+
583
+
init() {}
584
+
}
585
+
586
+
struct Rockbox_V1alpha1_GetTrackStatsRequest: Sendable {
587
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
588
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
589
+
// methods supported on all messages.
590
+
591
+
var trackID: String = String()
592
+
593
+
var unknownFields = SwiftProtobuf.UnknownStorage()
594
+
595
+
init() {}
596
+
}
597
+
598
+
struct Rockbox_V1alpha1_GetTrackStatsResponse: Sendable {
599
+
// SwiftProtobuf.Message conformance is added in an extension below. See the
600
+
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
601
+
// methods supported on all messages.
602
+
603
+
var stats: Rockbox_V1alpha1_TrackStats {
604
+
get {return _stats ?? Rockbox_V1alpha1_TrackStats()}
605
+
set {_stats = newValue}
606
+
}
607
+
/// Returns true if `stats` has been explicitly set.
608
+
var hasStats: Bool {return self._stats != nil}
609
+
/// Clears the value of `stats`. Subsequent reads from it will return its default value.
610
+
mutating func clearStats() {self._stats = nil}
611
+
612
+
var unknownFields = SwiftProtobuf.UnknownStorage()
613
+
614
+
init() {}
615
+
616
+
fileprivate var _stats: Rockbox_V1alpha1_TrackStats? = nil
617
+
}
618
+
619
+
// MARK: - Code below here is support for the SwiftProtobuf runtime.
620
+
621
+
fileprivate let _protobuf_package = "rockbox.v1alpha1"
622
+
623
+
extension Rockbox_V1alpha1_RuleCondition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
624
+
static let protoMessageName: String = _protobuf_package + ".RuleCondition"
625
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field\0\u{1}operator\0\u{1}value\0\u{2}value2\0\u{1}unit\0")
626
+
627
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
628
+
while let fieldNumber = try decoder.nextFieldNumber() {
629
+
// The use of inline closures is to circumvent an issue where the compiler
630
+
// allocates stack space for every case branch when no optimizations are
631
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
632
+
switch fieldNumber {
633
+
case 1: try { try decoder.decodeSingularStringField(value: &self.field) }()
634
+
case 2: try { try decoder.decodeSingularStringField(value: &self.operator_p) }()
635
+
case 3: try { try decoder.decodeSingularStringField(value: &self._value) }()
636
+
case 4: try { try decoder.decodeSingularStringField(value: &self._value2) }()
637
+
case 5: try { try decoder.decodeSingularStringField(value: &self._unit) }()
638
+
default: break
639
+
}
640
+
}
641
+
}
642
+
643
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
644
+
// The use of inline closures is to circumvent an issue where the compiler
645
+
// allocates stack space for every if/case branch local when no optimizations
646
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
647
+
// https://github.com/apple/swift-protobuf/issues/1182
648
+
if !self.field.isEmpty {
649
+
try visitor.visitSingularStringField(value: self.field, fieldNumber: 1)
650
+
}
651
+
if !self.operator_p.isEmpty {
652
+
try visitor.visitSingularStringField(value: self.operator_p, fieldNumber: 2)
653
+
}
654
+
try { if let v = self._value {
655
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
656
+
} }()
657
+
try { if let v = self._value2 {
658
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
659
+
} }()
660
+
try { if let v = self._unit {
661
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
662
+
} }()
663
+
try unknownFields.traverse(visitor: &visitor)
664
+
}
665
+
666
+
static func ==(lhs: Rockbox_V1alpha1_RuleCondition, rhs: Rockbox_V1alpha1_RuleCondition) -> Bool {
667
+
if lhs.field != rhs.field {return false}
668
+
if lhs.operator_p != rhs.operator_p {return false}
669
+
if lhs._value != rhs._value {return false}
670
+
if lhs._value2 != rhs._value2 {return false}
671
+
if lhs._unit != rhs._unit {return false}
672
+
if lhs.unknownFields != rhs.unknownFields {return false}
673
+
return true
674
+
}
675
+
}
676
+
677
+
extension Rockbox_V1alpha1_RuleCriteria: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
678
+
static let protoMessageName: String = _protobuf_package + ".RuleCriteria"
679
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}match_type\0\u{1}conditions\0\u{1}limit\0\u{3}sort_by\0\u{3}sort_order\0")
680
+
681
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
682
+
while let fieldNumber = try decoder.nextFieldNumber() {
683
+
// The use of inline closures is to circumvent an issue where the compiler
684
+
// allocates stack space for every case branch when no optimizations are
685
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
686
+
switch fieldNumber {
687
+
case 1: try { try decoder.decodeSingularStringField(value: &self.matchType) }()
688
+
case 2: try { try decoder.decodeRepeatedMessageField(value: &self.conditions) }()
689
+
case 3: try { try decoder.decodeSingularInt32Field(value: &self._limit) }()
690
+
case 4: try { try decoder.decodeSingularStringField(value: &self._sortBy) }()
691
+
case 5: try { try decoder.decodeSingularStringField(value: &self._sortOrder) }()
692
+
default: break
693
+
}
694
+
}
695
+
}
696
+
697
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
698
+
// The use of inline closures is to circumvent an issue where the compiler
699
+
// allocates stack space for every if/case branch local when no optimizations
700
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
701
+
// https://github.com/apple/swift-protobuf/issues/1182
702
+
if !self.matchType.isEmpty {
703
+
try visitor.visitSingularStringField(value: self.matchType, fieldNumber: 1)
704
+
}
705
+
if !self.conditions.isEmpty {
706
+
try visitor.visitRepeatedMessageField(value: self.conditions, fieldNumber: 2)
707
+
}
708
+
try { if let v = self._limit {
709
+
try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
710
+
} }()
711
+
try { if let v = self._sortBy {
712
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
713
+
} }()
714
+
try { if let v = self._sortOrder {
715
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
716
+
} }()
717
+
try unknownFields.traverse(visitor: &visitor)
718
+
}
719
+
720
+
static func ==(lhs: Rockbox_V1alpha1_RuleCriteria, rhs: Rockbox_V1alpha1_RuleCriteria) -> Bool {
721
+
if lhs.matchType != rhs.matchType {return false}
722
+
if lhs.conditions != rhs.conditions {return false}
723
+
if lhs._limit != rhs._limit {return false}
724
+
if lhs._sortBy != rhs._sortBy {return false}
725
+
if lhs._sortOrder != rhs._sortOrder {return false}
726
+
if lhs.unknownFields != rhs.unknownFields {return false}
727
+
return true
728
+
}
729
+
}
730
+
731
+
extension Rockbox_V1alpha1_SmartPlaylist: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
732
+
static let protoMessageName: String = _protobuf_package + ".SmartPlaylist"
733
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0\u{3}is_system\0\u{1}rules\0\u{3}created_at\0\u{3}updated_at\0")
734
+
735
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
736
+
_ = _uniqueStorage()
737
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
738
+
while let fieldNumber = try decoder.nextFieldNumber() {
739
+
// The use of inline closures is to circumvent an issue where the compiler
740
+
// allocates stack space for every case branch when no optimizations are
741
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
742
+
switch fieldNumber {
743
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
744
+
case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
745
+
case 3: try { try decoder.decodeSingularStringField(value: &_storage._description_p) }()
746
+
case 4: try { try decoder.decodeSingularStringField(value: &_storage._image) }()
747
+
case 5: try { try decoder.decodeSingularStringField(value: &_storage._folderID) }()
748
+
case 6: try { try decoder.decodeSingularBoolField(value: &self.isSystem) }()
749
+
case 7: try { try decoder.decodeSingularMessageField(value: &_storage._rules) }()
750
+
case 8: try { try decoder.decodeSingularInt64Field(value: &self.createdAt) }()
751
+
case 9: try { try decoder.decodeSingularInt64Field(value: &self.updatedAt) }()
752
+
default: break
753
+
}
754
+
}
755
+
}
756
+
}
757
+
758
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
759
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
760
+
// The use of inline closures is to circumvent an issue where the compiler
761
+
// allocates stack space for every if/case branch local when no optimizations
762
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
763
+
// https://github.com/apple/swift-protobuf/issues/1182
764
+
if !self.id.isEmpty {
765
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
766
+
}
767
+
if !self.name.isEmpty {
768
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
769
+
}
770
+
try { if let v = _storage._description_p {
771
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
772
+
} }()
773
+
try { if let v = _storage._image {
774
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
775
+
} }()
776
+
try { if let v = _storage._folderID {
777
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
778
+
} }()
779
+
if self.isSystem != false {
780
+
try visitor.visitSingularBoolField(value: self.isSystem, fieldNumber: 6)
781
+
}
782
+
try { if let v = _storage._rules {
783
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
784
+
} }()
785
+
if self.createdAt != 0 {
786
+
try visitor.visitSingularInt64Field(value: self.createdAt, fieldNumber: 8)
787
+
}
788
+
if self.updatedAt != 0 {
789
+
try visitor.visitSingularInt64Field(value: self.updatedAt, fieldNumber: 9)
790
+
}
791
+
}
792
+
try unknownFields.traverse(visitor: &visitor)
793
+
}
794
+
795
+
static func ==(lhs: Rockbox_V1alpha1_SmartPlaylist, rhs: Rockbox_V1alpha1_SmartPlaylist) -> Bool {
796
+
if lhs._storage !== rhs._storage {
797
+
let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
798
+
let _storage = _args.0
799
+
let rhs_storage = _args.1
800
+
if _storage._description_p != rhs_storage._description_p {return false}
801
+
if _storage._image != rhs_storage._image {return false}
802
+
if _storage._folderID != rhs_storage._folderID {return false}
803
+
if _storage._rules != rhs_storage._rules {return false}
804
+
return true
805
+
}
806
+
if !storagesAreEqual {return false}
807
+
}
808
+
if lhs.id != rhs.id {return false}
809
+
if lhs.name != rhs.name {return false}
810
+
if lhs.isSystem != rhs.isSystem {return false}
811
+
if lhs.createdAt != rhs.createdAt {return false}
812
+
if lhs.updatedAt != rhs.updatedAt {return false}
813
+
if lhs.unknownFields != rhs.unknownFields {return false}
814
+
return true
815
+
}
816
+
}
817
+
818
+
extension Rockbox_V1alpha1_GetSmartPlaylistsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
819
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistsRequest"
820
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
821
+
822
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
823
+
// Load everything into unknown fields
824
+
while try decoder.nextFieldNumber() != nil {}
825
+
}
826
+
827
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
828
+
try unknownFields.traverse(visitor: &visitor)
829
+
}
830
+
831
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistsRequest, rhs: Rockbox_V1alpha1_GetSmartPlaylistsRequest) -> Bool {
832
+
if lhs.unknownFields != rhs.unknownFields {return false}
833
+
return true
834
+
}
835
+
}
836
+
837
+
extension Rockbox_V1alpha1_GetSmartPlaylistsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
838
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistsResponse"
839
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlists\0")
840
+
841
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
842
+
while let fieldNumber = try decoder.nextFieldNumber() {
843
+
// The use of inline closures is to circumvent an issue where the compiler
844
+
// allocates stack space for every case branch when no optimizations are
845
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
846
+
switch fieldNumber {
847
+
case 1: try { try decoder.decodeRepeatedMessageField(value: &self.playlists) }()
848
+
default: break
849
+
}
850
+
}
851
+
}
852
+
853
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
854
+
if !self.playlists.isEmpty {
855
+
try visitor.visitRepeatedMessageField(value: self.playlists, fieldNumber: 1)
856
+
}
857
+
try unknownFields.traverse(visitor: &visitor)
858
+
}
859
+
860
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistsResponse, rhs: Rockbox_V1alpha1_GetSmartPlaylistsResponse) -> Bool {
861
+
if lhs.playlists != rhs.playlists {return false}
862
+
if lhs.unknownFields != rhs.unknownFields {return false}
863
+
return true
864
+
}
865
+
}
866
+
867
+
extension Rockbox_V1alpha1_GetSmartPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
868
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistRequest"
869
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
870
+
871
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
872
+
while let fieldNumber = try decoder.nextFieldNumber() {
873
+
// The use of inline closures is to circumvent an issue where the compiler
874
+
// allocates stack space for every case branch when no optimizations are
875
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
876
+
switch fieldNumber {
877
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
878
+
default: break
879
+
}
880
+
}
881
+
}
882
+
883
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
884
+
if !self.id.isEmpty {
885
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
886
+
}
887
+
try unknownFields.traverse(visitor: &visitor)
888
+
}
889
+
890
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistRequest, rhs: Rockbox_V1alpha1_GetSmartPlaylistRequest) -> Bool {
891
+
if lhs.id != rhs.id {return false}
892
+
if lhs.unknownFields != rhs.unknownFields {return false}
893
+
return true
894
+
}
895
+
}
896
+
897
+
extension Rockbox_V1alpha1_GetSmartPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
898
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistResponse"
899
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlist\0")
900
+
901
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
902
+
while let fieldNumber = try decoder.nextFieldNumber() {
903
+
// The use of inline closures is to circumvent an issue where the compiler
904
+
// allocates stack space for every case branch when no optimizations are
905
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
906
+
switch fieldNumber {
907
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._playlist) }()
908
+
default: break
909
+
}
910
+
}
911
+
}
912
+
913
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
914
+
// The use of inline closures is to circumvent an issue where the compiler
915
+
// allocates stack space for every if/case branch local when no optimizations
916
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
917
+
// https://github.com/apple/swift-protobuf/issues/1182
918
+
try { if let v = self._playlist {
919
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
920
+
} }()
921
+
try unknownFields.traverse(visitor: &visitor)
922
+
}
923
+
924
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistResponse, rhs: Rockbox_V1alpha1_GetSmartPlaylistResponse) -> Bool {
925
+
if lhs._playlist != rhs._playlist {return false}
926
+
if lhs.unknownFields != rhs.unknownFields {return false}
927
+
return true
928
+
}
929
+
}
930
+
931
+
extension Rockbox_V1alpha1_CreateSmartPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
932
+
static let protoMessageName: String = _protobuf_package + ".CreateSmartPlaylistRequest"
933
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0\u{1}rules\0")
934
+
935
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
936
+
_ = _uniqueStorage()
937
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
938
+
while let fieldNumber = try decoder.nextFieldNumber() {
939
+
// The use of inline closures is to circumvent an issue where the compiler
940
+
// allocates stack space for every case branch when no optimizations are
941
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
942
+
switch fieldNumber {
943
+
case 1: try { try decoder.decodeSingularStringField(value: &self.name) }()
944
+
case 2: try { try decoder.decodeSingularStringField(value: &_storage._description_p) }()
945
+
case 3: try { try decoder.decodeSingularStringField(value: &_storage._image) }()
946
+
case 4: try { try decoder.decodeSingularStringField(value: &_storage._folderID) }()
947
+
case 5: try { try decoder.decodeSingularMessageField(value: &_storage._rules) }()
948
+
default: break
949
+
}
950
+
}
951
+
}
952
+
}
953
+
954
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
955
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
956
+
// The use of inline closures is to circumvent an issue where the compiler
957
+
// allocates stack space for every if/case branch local when no optimizations
958
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
959
+
// https://github.com/apple/swift-protobuf/issues/1182
960
+
if !self.name.isEmpty {
961
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 1)
962
+
}
963
+
try { if let v = _storage._description_p {
964
+
try visitor.visitSingularStringField(value: v, fieldNumber: 2)
965
+
} }()
966
+
try { if let v = _storage._image {
967
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
968
+
} }()
969
+
try { if let v = _storage._folderID {
970
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
971
+
} }()
972
+
try { if let v = _storage._rules {
973
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
974
+
} }()
975
+
}
976
+
try unknownFields.traverse(visitor: &visitor)
977
+
}
978
+
979
+
static func ==(lhs: Rockbox_V1alpha1_CreateSmartPlaylistRequest, rhs: Rockbox_V1alpha1_CreateSmartPlaylistRequest) -> Bool {
980
+
if lhs._storage !== rhs._storage {
981
+
let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
982
+
let _storage = _args.0
983
+
let rhs_storage = _args.1
984
+
if _storage._description_p != rhs_storage._description_p {return false}
985
+
if _storage._image != rhs_storage._image {return false}
986
+
if _storage._folderID != rhs_storage._folderID {return false}
987
+
if _storage._rules != rhs_storage._rules {return false}
988
+
return true
989
+
}
990
+
if !storagesAreEqual {return false}
991
+
}
992
+
if lhs.name != rhs.name {return false}
993
+
if lhs.unknownFields != rhs.unknownFields {return false}
994
+
return true
995
+
}
996
+
}
997
+
998
+
extension Rockbox_V1alpha1_CreateSmartPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
999
+
static let protoMessageName: String = _protobuf_package + ".CreateSmartPlaylistResponse"
1000
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}playlist\0")
1001
+
1002
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1003
+
while let fieldNumber = try decoder.nextFieldNumber() {
1004
+
// The use of inline closures is to circumvent an issue where the compiler
1005
+
// allocates stack space for every case branch when no optimizations are
1006
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1007
+
switch fieldNumber {
1008
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._playlist) }()
1009
+
default: break
1010
+
}
1011
+
}
1012
+
}
1013
+
1014
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1015
+
// The use of inline closures is to circumvent an issue where the compiler
1016
+
// allocates stack space for every if/case branch local when no optimizations
1017
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
1018
+
// https://github.com/apple/swift-protobuf/issues/1182
1019
+
try { if let v = self._playlist {
1020
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
1021
+
} }()
1022
+
try unknownFields.traverse(visitor: &visitor)
1023
+
}
1024
+
1025
+
static func ==(lhs: Rockbox_V1alpha1_CreateSmartPlaylistResponse, rhs: Rockbox_V1alpha1_CreateSmartPlaylistResponse) -> Bool {
1026
+
if lhs._playlist != rhs._playlist {return false}
1027
+
if lhs.unknownFields != rhs.unknownFields {return false}
1028
+
return true
1029
+
}
1030
+
}
1031
+
1032
+
extension Rockbox_V1alpha1_UpdateSmartPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1033
+
static let protoMessageName: String = _protobuf_package + ".UpdateSmartPlaylistRequest"
1034
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}name\0\u{1}description\0\u{1}image\0\u{3}folder_id\0\u{1}rules\0")
1035
+
1036
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1037
+
_ = _uniqueStorage()
1038
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
1039
+
while let fieldNumber = try decoder.nextFieldNumber() {
1040
+
// The use of inline closures is to circumvent an issue where the compiler
1041
+
// allocates stack space for every case branch when no optimizations are
1042
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1043
+
switch fieldNumber {
1044
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
1045
+
case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
1046
+
case 3: try { try decoder.decodeSingularStringField(value: &_storage._description_p) }()
1047
+
case 4: try { try decoder.decodeSingularStringField(value: &_storage._image) }()
1048
+
case 5: try { try decoder.decodeSingularStringField(value: &_storage._folderID) }()
1049
+
case 6: try { try decoder.decodeSingularMessageField(value: &_storage._rules) }()
1050
+
default: break
1051
+
}
1052
+
}
1053
+
}
1054
+
}
1055
+
1056
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1057
+
try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
1058
+
// The use of inline closures is to circumvent an issue where the compiler
1059
+
// allocates stack space for every if/case branch local when no optimizations
1060
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
1061
+
// https://github.com/apple/swift-protobuf/issues/1182
1062
+
if !self.id.isEmpty {
1063
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
1064
+
}
1065
+
if !self.name.isEmpty {
1066
+
try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
1067
+
}
1068
+
try { if let v = _storage._description_p {
1069
+
try visitor.visitSingularStringField(value: v, fieldNumber: 3)
1070
+
} }()
1071
+
try { if let v = _storage._image {
1072
+
try visitor.visitSingularStringField(value: v, fieldNumber: 4)
1073
+
} }()
1074
+
try { if let v = _storage._folderID {
1075
+
try visitor.visitSingularStringField(value: v, fieldNumber: 5)
1076
+
} }()
1077
+
try { if let v = _storage._rules {
1078
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
1079
+
} }()
1080
+
}
1081
+
try unknownFields.traverse(visitor: &visitor)
1082
+
}
1083
+
1084
+
static func ==(lhs: Rockbox_V1alpha1_UpdateSmartPlaylistRequest, rhs: Rockbox_V1alpha1_UpdateSmartPlaylistRequest) -> Bool {
1085
+
if lhs._storage !== rhs._storage {
1086
+
let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
1087
+
let _storage = _args.0
1088
+
let rhs_storage = _args.1
1089
+
if _storage._description_p != rhs_storage._description_p {return false}
1090
+
if _storage._image != rhs_storage._image {return false}
1091
+
if _storage._folderID != rhs_storage._folderID {return false}
1092
+
if _storage._rules != rhs_storage._rules {return false}
1093
+
return true
1094
+
}
1095
+
if !storagesAreEqual {return false}
1096
+
}
1097
+
if lhs.id != rhs.id {return false}
1098
+
if lhs.name != rhs.name {return false}
1099
+
if lhs.unknownFields != rhs.unknownFields {return false}
1100
+
return true
1101
+
}
1102
+
}
1103
+
1104
+
extension Rockbox_V1alpha1_UpdateSmartPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1105
+
static let protoMessageName: String = _protobuf_package + ".UpdateSmartPlaylistResponse"
1106
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1107
+
1108
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1109
+
// Load everything into unknown fields
1110
+
while try decoder.nextFieldNumber() != nil {}
1111
+
}
1112
+
1113
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1114
+
try unknownFields.traverse(visitor: &visitor)
1115
+
}
1116
+
1117
+
static func ==(lhs: Rockbox_V1alpha1_UpdateSmartPlaylistResponse, rhs: Rockbox_V1alpha1_UpdateSmartPlaylistResponse) -> Bool {
1118
+
if lhs.unknownFields != rhs.unknownFields {return false}
1119
+
return true
1120
+
}
1121
+
}
1122
+
1123
+
extension Rockbox_V1alpha1_DeleteSmartPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1124
+
static let protoMessageName: String = _protobuf_package + ".DeleteSmartPlaylistRequest"
1125
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
1126
+
1127
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1128
+
while let fieldNumber = try decoder.nextFieldNumber() {
1129
+
// The use of inline closures is to circumvent an issue where the compiler
1130
+
// allocates stack space for every case branch when no optimizations are
1131
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1132
+
switch fieldNumber {
1133
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
1134
+
default: break
1135
+
}
1136
+
}
1137
+
}
1138
+
1139
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1140
+
if !self.id.isEmpty {
1141
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
1142
+
}
1143
+
try unknownFields.traverse(visitor: &visitor)
1144
+
}
1145
+
1146
+
static func ==(lhs: Rockbox_V1alpha1_DeleteSmartPlaylistRequest, rhs: Rockbox_V1alpha1_DeleteSmartPlaylistRequest) -> Bool {
1147
+
if lhs.id != rhs.id {return false}
1148
+
if lhs.unknownFields != rhs.unknownFields {return false}
1149
+
return true
1150
+
}
1151
+
}
1152
+
1153
+
extension Rockbox_V1alpha1_DeleteSmartPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1154
+
static let protoMessageName: String = _protobuf_package + ".DeleteSmartPlaylistResponse"
1155
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1156
+
1157
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1158
+
// Load everything into unknown fields
1159
+
while try decoder.nextFieldNumber() != nil {}
1160
+
}
1161
+
1162
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1163
+
try unknownFields.traverse(visitor: &visitor)
1164
+
}
1165
+
1166
+
static func ==(lhs: Rockbox_V1alpha1_DeleteSmartPlaylistResponse, rhs: Rockbox_V1alpha1_DeleteSmartPlaylistResponse) -> Bool {
1167
+
if lhs.unknownFields != rhs.unknownFields {return false}
1168
+
return true
1169
+
}
1170
+
}
1171
+
1172
+
extension Rockbox_V1alpha1_GetSmartPlaylistTracksRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1173
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistTracksRequest"
1174
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
1175
+
1176
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1177
+
while let fieldNumber = try decoder.nextFieldNumber() {
1178
+
// The use of inline closures is to circumvent an issue where the compiler
1179
+
// allocates stack space for every case branch when no optimizations are
1180
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1181
+
switch fieldNumber {
1182
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
1183
+
default: break
1184
+
}
1185
+
}
1186
+
}
1187
+
1188
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1189
+
if !self.id.isEmpty {
1190
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
1191
+
}
1192
+
try unknownFields.traverse(visitor: &visitor)
1193
+
}
1194
+
1195
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistTracksRequest, rhs: Rockbox_V1alpha1_GetSmartPlaylistTracksRequest) -> Bool {
1196
+
if lhs.id != rhs.id {return false}
1197
+
if lhs.unknownFields != rhs.unknownFields {return false}
1198
+
return true
1199
+
}
1200
+
}
1201
+
1202
+
extension Rockbox_V1alpha1_GetSmartPlaylistTracksResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1203
+
static let protoMessageName: String = _protobuf_package + ".GetSmartPlaylistTracksResponse"
1204
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_ids\0")
1205
+
1206
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1207
+
while let fieldNumber = try decoder.nextFieldNumber() {
1208
+
// The use of inline closures is to circumvent an issue where the compiler
1209
+
// allocates stack space for every case branch when no optimizations are
1210
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1211
+
switch fieldNumber {
1212
+
case 1: try { try decoder.decodeRepeatedStringField(value: &self.trackIDs) }()
1213
+
default: break
1214
+
}
1215
+
}
1216
+
}
1217
+
1218
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1219
+
if !self.trackIDs.isEmpty {
1220
+
try visitor.visitRepeatedStringField(value: self.trackIDs, fieldNumber: 1)
1221
+
}
1222
+
try unknownFields.traverse(visitor: &visitor)
1223
+
}
1224
+
1225
+
static func ==(lhs: Rockbox_V1alpha1_GetSmartPlaylistTracksResponse, rhs: Rockbox_V1alpha1_GetSmartPlaylistTracksResponse) -> Bool {
1226
+
if lhs.trackIDs != rhs.trackIDs {return false}
1227
+
if lhs.unknownFields != rhs.unknownFields {return false}
1228
+
return true
1229
+
}
1230
+
}
1231
+
1232
+
extension Rockbox_V1alpha1_PlaySmartPlaylistRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1233
+
static let protoMessageName: String = _protobuf_package + ".PlaySmartPlaylistRequest"
1234
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")
1235
+
1236
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1237
+
while let fieldNumber = try decoder.nextFieldNumber() {
1238
+
// The use of inline closures is to circumvent an issue where the compiler
1239
+
// allocates stack space for every case branch when no optimizations are
1240
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1241
+
switch fieldNumber {
1242
+
case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
1243
+
default: break
1244
+
}
1245
+
}
1246
+
}
1247
+
1248
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1249
+
if !self.id.isEmpty {
1250
+
try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
1251
+
}
1252
+
try unknownFields.traverse(visitor: &visitor)
1253
+
}
1254
+
1255
+
static func ==(lhs: Rockbox_V1alpha1_PlaySmartPlaylistRequest, rhs: Rockbox_V1alpha1_PlaySmartPlaylistRequest) -> Bool {
1256
+
if lhs.id != rhs.id {return false}
1257
+
if lhs.unknownFields != rhs.unknownFields {return false}
1258
+
return true
1259
+
}
1260
+
}
1261
+
1262
+
extension Rockbox_V1alpha1_PlaySmartPlaylistResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1263
+
static let protoMessageName: String = _protobuf_package + ".PlaySmartPlaylistResponse"
1264
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1265
+
1266
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1267
+
// Load everything into unknown fields
1268
+
while try decoder.nextFieldNumber() != nil {}
1269
+
}
1270
+
1271
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1272
+
try unknownFields.traverse(visitor: &visitor)
1273
+
}
1274
+
1275
+
static func ==(lhs: Rockbox_V1alpha1_PlaySmartPlaylistResponse, rhs: Rockbox_V1alpha1_PlaySmartPlaylistResponse) -> Bool {
1276
+
if lhs.unknownFields != rhs.unknownFields {return false}
1277
+
return true
1278
+
}
1279
+
}
1280
+
1281
+
extension Rockbox_V1alpha1_TrackStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1282
+
static let protoMessageName: String = _protobuf_package + ".TrackStats"
1283
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_id\0\u{3}play_count\0\u{3}skip_count\0\u{3}last_played\0\u{3}last_skipped\0\u{3}updated_at\0")
1284
+
1285
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1286
+
while let fieldNumber = try decoder.nextFieldNumber() {
1287
+
// The use of inline closures is to circumvent an issue where the compiler
1288
+
// allocates stack space for every case branch when no optimizations are
1289
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1290
+
switch fieldNumber {
1291
+
case 1: try { try decoder.decodeSingularStringField(value: &self.trackID) }()
1292
+
case 2: try { try decoder.decodeSingularInt64Field(value: &self.playCount) }()
1293
+
case 3: try { try decoder.decodeSingularInt64Field(value: &self.skipCount) }()
1294
+
case 4: try { try decoder.decodeSingularInt64Field(value: &self._lastPlayed) }()
1295
+
case 5: try { try decoder.decodeSingularInt64Field(value: &self._lastSkipped) }()
1296
+
case 6: try { try decoder.decodeSingularInt64Field(value: &self.updatedAt) }()
1297
+
default: break
1298
+
}
1299
+
}
1300
+
}
1301
+
1302
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1303
+
// The use of inline closures is to circumvent an issue where the compiler
1304
+
// allocates stack space for every if/case branch local when no optimizations
1305
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
1306
+
// https://github.com/apple/swift-protobuf/issues/1182
1307
+
if !self.trackID.isEmpty {
1308
+
try visitor.visitSingularStringField(value: self.trackID, fieldNumber: 1)
1309
+
}
1310
+
if self.playCount != 0 {
1311
+
try visitor.visitSingularInt64Field(value: self.playCount, fieldNumber: 2)
1312
+
}
1313
+
if self.skipCount != 0 {
1314
+
try visitor.visitSingularInt64Field(value: self.skipCount, fieldNumber: 3)
1315
+
}
1316
+
try { if let v = self._lastPlayed {
1317
+
try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
1318
+
} }()
1319
+
try { if let v = self._lastSkipped {
1320
+
try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
1321
+
} }()
1322
+
if self.updatedAt != 0 {
1323
+
try visitor.visitSingularInt64Field(value: self.updatedAt, fieldNumber: 6)
1324
+
}
1325
+
try unknownFields.traverse(visitor: &visitor)
1326
+
}
1327
+
1328
+
static func ==(lhs: Rockbox_V1alpha1_TrackStats, rhs: Rockbox_V1alpha1_TrackStats) -> Bool {
1329
+
if lhs.trackID != rhs.trackID {return false}
1330
+
if lhs.playCount != rhs.playCount {return false}
1331
+
if lhs.skipCount != rhs.skipCount {return false}
1332
+
if lhs._lastPlayed != rhs._lastPlayed {return false}
1333
+
if lhs._lastSkipped != rhs._lastSkipped {return false}
1334
+
if lhs.updatedAt != rhs.updatedAt {return false}
1335
+
if lhs.unknownFields != rhs.unknownFields {return false}
1336
+
return true
1337
+
}
1338
+
}
1339
+
1340
+
extension Rockbox_V1alpha1_RecordTrackPlayedRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1341
+
static let protoMessageName: String = _protobuf_package + ".RecordTrackPlayedRequest"
1342
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_id\0")
1343
+
1344
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1345
+
while let fieldNumber = try decoder.nextFieldNumber() {
1346
+
// The use of inline closures is to circumvent an issue where the compiler
1347
+
// allocates stack space for every case branch when no optimizations are
1348
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1349
+
switch fieldNumber {
1350
+
case 1: try { try decoder.decodeSingularStringField(value: &self.trackID) }()
1351
+
default: break
1352
+
}
1353
+
}
1354
+
}
1355
+
1356
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1357
+
if !self.trackID.isEmpty {
1358
+
try visitor.visitSingularStringField(value: self.trackID, fieldNumber: 1)
1359
+
}
1360
+
try unknownFields.traverse(visitor: &visitor)
1361
+
}
1362
+
1363
+
static func ==(lhs: Rockbox_V1alpha1_RecordTrackPlayedRequest, rhs: Rockbox_V1alpha1_RecordTrackPlayedRequest) -> Bool {
1364
+
if lhs.trackID != rhs.trackID {return false}
1365
+
if lhs.unknownFields != rhs.unknownFields {return false}
1366
+
return true
1367
+
}
1368
+
}
1369
+
1370
+
extension Rockbox_V1alpha1_RecordTrackPlayedResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1371
+
static let protoMessageName: String = _protobuf_package + ".RecordTrackPlayedResponse"
1372
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1373
+
1374
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1375
+
// Load everything into unknown fields
1376
+
while try decoder.nextFieldNumber() != nil {}
1377
+
}
1378
+
1379
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1380
+
try unknownFields.traverse(visitor: &visitor)
1381
+
}
1382
+
1383
+
static func ==(lhs: Rockbox_V1alpha1_RecordTrackPlayedResponse, rhs: Rockbox_V1alpha1_RecordTrackPlayedResponse) -> Bool {
1384
+
if lhs.unknownFields != rhs.unknownFields {return false}
1385
+
return true
1386
+
}
1387
+
}
1388
+
1389
+
extension Rockbox_V1alpha1_RecordTrackSkippedRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1390
+
static let protoMessageName: String = _protobuf_package + ".RecordTrackSkippedRequest"
1391
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_id\0")
1392
+
1393
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1394
+
while let fieldNumber = try decoder.nextFieldNumber() {
1395
+
// The use of inline closures is to circumvent an issue where the compiler
1396
+
// allocates stack space for every case branch when no optimizations are
1397
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1398
+
switch fieldNumber {
1399
+
case 1: try { try decoder.decodeSingularStringField(value: &self.trackID) }()
1400
+
default: break
1401
+
}
1402
+
}
1403
+
}
1404
+
1405
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1406
+
if !self.trackID.isEmpty {
1407
+
try visitor.visitSingularStringField(value: self.trackID, fieldNumber: 1)
1408
+
}
1409
+
try unknownFields.traverse(visitor: &visitor)
1410
+
}
1411
+
1412
+
static func ==(lhs: Rockbox_V1alpha1_RecordTrackSkippedRequest, rhs: Rockbox_V1alpha1_RecordTrackSkippedRequest) -> Bool {
1413
+
if lhs.trackID != rhs.trackID {return false}
1414
+
if lhs.unknownFields != rhs.unknownFields {return false}
1415
+
return true
1416
+
}
1417
+
}
1418
+
1419
+
extension Rockbox_V1alpha1_RecordTrackSkippedResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1420
+
static let protoMessageName: String = _protobuf_package + ".RecordTrackSkippedResponse"
1421
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap()
1422
+
1423
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1424
+
// Load everything into unknown fields
1425
+
while try decoder.nextFieldNumber() != nil {}
1426
+
}
1427
+
1428
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1429
+
try unknownFields.traverse(visitor: &visitor)
1430
+
}
1431
+
1432
+
static func ==(lhs: Rockbox_V1alpha1_RecordTrackSkippedResponse, rhs: Rockbox_V1alpha1_RecordTrackSkippedResponse) -> Bool {
1433
+
if lhs.unknownFields != rhs.unknownFields {return false}
1434
+
return true
1435
+
}
1436
+
}
1437
+
1438
+
extension Rockbox_V1alpha1_GetTrackStatsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1439
+
static let protoMessageName: String = _protobuf_package + ".GetTrackStatsRequest"
1440
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}track_id\0")
1441
+
1442
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1443
+
while let fieldNumber = try decoder.nextFieldNumber() {
1444
+
// The use of inline closures is to circumvent an issue where the compiler
1445
+
// allocates stack space for every case branch when no optimizations are
1446
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1447
+
switch fieldNumber {
1448
+
case 1: try { try decoder.decodeSingularStringField(value: &self.trackID) }()
1449
+
default: break
1450
+
}
1451
+
}
1452
+
}
1453
+
1454
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1455
+
if !self.trackID.isEmpty {
1456
+
try visitor.visitSingularStringField(value: self.trackID, fieldNumber: 1)
1457
+
}
1458
+
try unknownFields.traverse(visitor: &visitor)
1459
+
}
1460
+
1461
+
static func ==(lhs: Rockbox_V1alpha1_GetTrackStatsRequest, rhs: Rockbox_V1alpha1_GetTrackStatsRequest) -> Bool {
1462
+
if lhs.trackID != rhs.trackID {return false}
1463
+
if lhs.unknownFields != rhs.unknownFields {return false}
1464
+
return true
1465
+
}
1466
+
}
1467
+
1468
+
extension Rockbox_V1alpha1_GetTrackStatsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
1469
+
static let protoMessageName: String = _protobuf_package + ".GetTrackStatsResponse"
1470
+
static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stats\0")
1471
+
1472
+
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
1473
+
while let fieldNumber = try decoder.nextFieldNumber() {
1474
+
// The use of inline closures is to circumvent an issue where the compiler
1475
+
// allocates stack space for every case branch when no optimizations are
1476
+
// enabled. https://github.com/apple/swift-protobuf/issues/1034
1477
+
switch fieldNumber {
1478
+
case 1: try { try decoder.decodeSingularMessageField(value: &self._stats) }()
1479
+
default: break
1480
+
}
1481
+
}
1482
+
}
1483
+
1484
+
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
1485
+
// The use of inline closures is to circumvent an issue where the compiler
1486
+
// allocates stack space for every if/case branch local when no optimizations
1487
+
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
1488
+
// https://github.com/apple/swift-protobuf/issues/1182
1489
+
try { if let v = self._stats {
1490
+
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
1491
+
} }()
1492
+
try unknownFields.traverse(visitor: &visitor)
1493
+
}
1494
+
1495
+
static func ==(lhs: Rockbox_V1alpha1_GetTrackStatsResponse, rhs: Rockbox_V1alpha1_GetTrackStatsResponse) -> Bool {
1496
+
if lhs._stats != rhs._stats {return false}
1497
+
if lhs.unknownFields != rhs.unknownFields {return false}
1498
+
return true
1499
+
}
1500
+
}
+52
-7
macos/Rockbox/Views/AlbumDetail/AlbumTrackView.swift
+52
-7
macos/Rockbox/Views/AlbumDetail/AlbumTrackView.swift
···
13
13
let isEven: Bool
14
14
let albumID: String
15
15
@State private var errorText: String?
16
+
@State private var savedPlaylists: [SavedPlaylist] = []
16
17
@State private var isHoveringMenu: Bool = false
17
18
@ObservedObject var library: MusicLibrary
18
19
@EnvironmentObject var player: PlayerState
···
91
92
Label("Play Next", systemImage: "text.insert")
92
93
}
93
94
94
-
Button(action: {
95
-
Task {
96
-
do {
97
-
// Add to Playlist
98
-
} catch {
99
-
errorText = String(describing: error)
95
+
Menu {
96
+
Button(action: {
97
+
Task {
98
+
do {
99
+
let pl = try await createSavedPlaylist(
100
+
name: track.title, trackIDs: [track.cuid])
101
+
let saved = SavedPlaylist(
102
+
id: pl.id, name: pl.name,
103
+
description: nil, image: nil, folderID: nil,
104
+
trackCount: pl.trackCount)
105
+
savedPlaylists.append(saved)
106
+
} catch {
107
+
errorText = String(describing: error)
108
+
}
109
+
}
110
+
}) {
111
+
Label("New Playlist...", systemImage: "plus")
112
+
}
113
+
if !savedPlaylists.isEmpty {
114
+
Divider()
115
+
ForEach(savedPlaylists) { pl in
116
+
Button(action: {
117
+
Task {
118
+
do {
119
+
try await addTracksToSavedPlaylist(
120
+
playlistID: pl.id, trackIDs: [track.cuid])
121
+
} catch {
122
+
errorText = String(describing: error)
123
+
}
124
+
}
125
+
}) {
126
+
Label(pl.name, systemImage: "music.note.list")
127
+
}
100
128
}
101
129
}
102
-
}) {
130
+
} label: {
103
131
Label("Add to Playlist", systemImage: "text.append")
104
132
}
133
+
.menuStyle(.borderlessButton)
134
+
.menuIndicator(.hidden)
105
135
106
136
Button(action: {
107
137
Task {
···
157
187
.onHover { hovering in
158
188
withAnimation(.easeInOut(duration: 0.15)) {
159
189
isHovering = hovering
190
+
}
191
+
}
192
+
.task {
193
+
if savedPlaylists.isEmpty {
194
+
if let data = try? await fetchSavedPlaylists() {
195
+
savedPlaylists = data.map {
196
+
SavedPlaylist(
197
+
id: $0.id, name: $0.name,
198
+
description: $0.hasDescription_p ? $0.description_p : nil,
199
+
image: $0.hasImage ? $0.image : nil,
200
+
folderID: $0.hasFolderID ? $0.folderID : nil,
201
+
trackCount: $0.trackCount
202
+
)
203
+
}
204
+
}
160
205
}
161
206
}
162
207
}
+27
-9
macos/Rockbox/Views/Albums/AlbumCardView.swift
+27
-9
macos/Rockbox/Views/Albums/AlbumCardView.swift
···
8
8
9
9
struct AlbumCardView: View {
10
10
let album: Album
11
-
var playlists: [Playlist] = []
11
+
var savedPlaylists: [SavedPlaylist] = []
12
12
@EnvironmentObject var player: PlayerState
13
13
@EnvironmentObject var navigation: NavigationManager
14
14
···
146
146
title: "Add to Playlist",
147
147
icon: "music.note.list",
148
148
hasSubmenu: true,
149
-
submenuItems: playlists,
149
+
savedPlaylists: savedPlaylists,
150
150
onSubmenuSelect: { playlist in
151
151
showMenu = false
152
-
// Add to selected playlist
152
+
Task {
153
+
do {
154
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
155
+
let trackIDs = tracks.map { $0.id }
156
+
try await addTracksToSavedPlaylist(
157
+
playlistID: playlist.id, trackIDs: trackIDs)
158
+
} catch {
159
+
errorText = String(describing: error)
160
+
}
161
+
}
153
162
},
154
163
onCreateNew: {
155
164
showMenu = false
156
-
// Create new playlist
165
+
Task {
166
+
do {
167
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
168
+
let trackIDs = tracks.map { $0.id }
169
+
let _ = try await createSavedPlaylist(
170
+
name: album.title, trackIDs: trackIDs)
171
+
} catch {
172
+
errorText = String(describing: error)
173
+
}
174
+
}
157
175
},
158
176
action: {}
159
177
)
···
250
268
let title: String
251
269
let icon: String
252
270
var hasSubmenu: Bool = false
253
-
var submenuItems: [Playlist] = []
254
-
var onSubmenuSelect: ((Playlist) -> Void)? = nil
271
+
var savedPlaylists: [SavedPlaylist] = []
272
+
var onSubmenuSelect: ((SavedPlaylist) -> Void)? = nil
255
273
var onCreateNew: (() -> Void)? = nil
256
274
let action: () -> Void
257
275
···
264
282
Label("New Playlist...", systemImage: "plus")
265
283
}
266
284
267
-
if !submenuItems.isEmpty {
285
+
if !savedPlaylists.isEmpty {
268
286
Divider()
269
-
270
-
ForEach(submenuItems) { playlist in
287
+
288
+
ForEach(savedPlaylists) { playlist in
271
289
Button(action: { onSubmenuSelect?(playlist) }) {
272
290
Label(playlist.name, systemImage: "music.note.list")
273
291
}
+26
-15
macos/Rockbox/Views/Albums/AlbumsGridView.swift
+26
-15
macos/Rockbox/Views/Albums/AlbumsGridView.swift
···
16
16
GridItem(.adaptive(minimum: 170, maximum: 230), spacing: 20)
17
17
]
18
18
19
+
@State private var savedPlaylists: [SavedPlaylist] = []
20
+
19
21
var body: some View {
20
22
ScrollView {
21
23
LazyVGrid(columns: columns, spacing: 24) {
22
24
ForEach(albums) { album in
23
-
AlbumCardView(album: album, playlists: []) {
25
+
AlbumCardView(album: album, savedPlaylists: savedPlaylists) {
24
26
selectedAlbum = album
25
27
}
26
28
}
···
29
31
}
30
32
.task {
31
33
do {
32
-
let data = try await fetchAlbums()
33
-
albums = []
34
-
for album in data {
35
-
albums.append(Album(
36
-
cuid: album.id,
37
-
title: album.title,
38
-
artist: album.artist,
39
-
year: Int(album.year),
34
+
async let albumData = fetchAlbums()
35
+
async let playlistData = fetchSavedPlaylists()
36
+
let (data, plData) = try await (albumData, playlistData)
37
+
albums = data.map {
38
+
Album(
39
+
cuid: $0.id,
40
+
title: $0.title,
41
+
artist: $0.artist,
42
+
year: Int($0.year),
40
43
color: .gray.opacity(0.3),
41
-
cover: "http://localhost:6062/covers/" + album.albumArt,
42
-
releaseDate: album.yearString,
43
-
copyrightMessage: album.copyrightMessage,
44
-
artistID: album.artistID,
44
+
cover: "http://localhost:6062/covers/" + $0.albumArt,
45
+
releaseDate: $0.yearString,
46
+
copyrightMessage: $0.copyrightMessage,
47
+
artistID: $0.artistID,
45
48
tracks: []
46
-
))
49
+
)
47
50
}
48
-
51
+
savedPlaylists = plData.map {
52
+
SavedPlaylist(
53
+
id: $0.id, name: $0.name,
54
+
description: $0.hasDescription_p ? $0.description_p : nil,
55
+
image: $0.hasImage ? $0.image : nil,
56
+
folderID: $0.hasFolderID ? $0.folderID : nil,
57
+
trackCount: $0.trackCount
58
+
)
59
+
}
49
60
} catch {
50
61
errorText = String(describing: error)
51
62
}
+22
-4
macos/Rockbox/Views/ArtistDetail/ArtistAlbumCardView.swift
+22
-4
macos/Rockbox/Views/ArtistDetail/ArtistAlbumCardView.swift
···
9
9
10
10
struct ArtistAlbumCardView: View {
11
11
let album: Album
12
-
var playlists: [Playlist] = []
12
+
var savedPlaylists: [SavedPlaylist] = []
13
13
var onSelect: () -> Void
14
14
15
15
@State private var isHovering = false
···
147
147
title: "Add to Playlist",
148
148
icon: "music.note.list",
149
149
hasSubmenu: true,
150
-
submenuItems: playlists,
150
+
savedPlaylists: savedPlaylists,
151
151
onSubmenuSelect: { playlist in
152
152
showMenu = false
153
-
// Add to selected playlist
153
+
Task {
154
+
do {
155
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
156
+
try await addTracksToSavedPlaylist(
157
+
playlistID: playlist.id,
158
+
trackIDs: tracks.map { $0.id })
159
+
} catch {
160
+
errorText = String(describing: error)
161
+
}
162
+
}
154
163
},
155
164
onCreateNew: {
156
165
showMenu = false
157
-
// Create new playlist
166
+
Task {
167
+
do {
168
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
169
+
let _ = try await createSavedPlaylist(
170
+
name: album.title,
171
+
trackIDs: tracks.map { $0.id })
172
+
} catch {
173
+
errorText = String(describing: error)
174
+
}
175
+
}
158
176
},
159
177
action: {}
160
178
)
+15
-3
macos/Rockbox/Views/Main/DetailView.swift
+15
-3
macos/Rockbox/Views/Main/DetailView.swift
···
61
61
} else if let album = navigation.selectedAlbum {
62
62
AlbumDetailView(
63
63
album: album, library: library,
64
-
onBack: {
65
-
navigation.selectedAlbum = nil
66
-
})
64
+
onBack: { navigation.selectedAlbum = nil })
67
65
} else if let artist = navigation.selectedArtist {
68
66
ArtistDetailView(
69
67
artist: artist,
70
68
library: library,
71
69
onBack: { navigation.selectedArtist = nil },
72
70
onAlbumSelected: { album in navigation.goToAlbum(album) }
71
+
)
72
+
} else if let playlist = navigation.selectedPlaylist {
73
+
SavedPlaylistDetailView(
74
+
playlist: playlist,
75
+
library: library,
76
+
onBack: { navigation.selectedPlaylist = nil }
77
+
)
78
+
} else if let smartPlaylist = navigation.selectedSmartPlaylist {
79
+
SmartPlaylistDetailView(
80
+
playlist: smartPlaylist,
81
+
library: library,
82
+
onBack: { navigation.selectedSmartPlaylist = nil }
73
83
)
74
84
} else if let selection {
75
85
selectionView(for: selection)
···
91
101
SongsListView(library: library)
92
102
case .likes:
93
103
LikesListView(library: library)
104
+
case .playlists:
105
+
PlaylistsView()
94
106
case .files:
95
107
FilesListView()
96
108
}
+268
macos/Rockbox/Views/PlaylistDetail/SavedPlaylistDetailView.swift
+268
macos/Rockbox/Views/PlaylistDetail/SavedPlaylistDetailView.swift
···
1
+
//
2
+
// SavedPlaylistDetailView.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import SwiftUI
7
+
8
+
struct SavedPlaylistDetailView: View {
9
+
let playlist: SavedPlaylist
10
+
@ObservedObject var library: MusicLibrary
11
+
var onBack: () -> Void
12
+
13
+
@EnvironmentObject var player: PlayerState
14
+
@State private var tracks: [Song] = []
15
+
@State private var errorText: String?
16
+
@State private var showEditSheet = false
17
+
@State private var editName = ""
18
+
19
+
var totalDuration: TimeInterval {
20
+
tracks.reduce(0) { $0 + $1.duration }
21
+
}
22
+
23
+
var body: some View {
24
+
ScrollView {
25
+
VStack(spacing: 0) {
26
+
// Header
27
+
ZStack(alignment: .topLeading) {
28
+
LinearGradient(
29
+
colors: [Color.accentColor.opacity(0.4), Color.clear],
30
+
startPoint: .top, endPoint: .bottom
31
+
)
32
+
.frame(height: 220)
33
+
34
+
VStack(alignment: .leading, spacing: 0) {
35
+
Button(action: onBack) {
36
+
HStack(spacing: 4) {
37
+
Image(systemName: "chevron.left")
38
+
Text("Back")
39
+
}
40
+
.font(.system(size: 13))
41
+
.foregroundStyle(.primary)
42
+
}
43
+
.buttonStyle(.plain)
44
+
.padding(.top, 16)
45
+
.padding(.horizontal, 24)
46
+
47
+
HStack(alignment: .bottom, spacing: 20) {
48
+
RoundedRectangle(cornerRadius: 8)
49
+
.fill(Color.gray.opacity(0.3).gradient)
50
+
.frame(width: 120, height: 120)
51
+
.overlay {
52
+
if let img = playlist.image, !img.isEmpty {
53
+
CachedAsyncImage(url: URL(string: "http://localhost:6062/covers/" + img)) { phase in
54
+
switch phase {
55
+
case .success(let image):
56
+
image.resizable().aspectRatio(contentMode: .fill)
57
+
default:
58
+
Image(systemName: "music.note.list")
59
+
.font(.system(size: 40))
60
+
.foregroundStyle(.white.opacity(0.6))
61
+
}
62
+
}
63
+
} else {
64
+
Image(systemName: "music.note.list")
65
+
.font(.system(size: 40))
66
+
.foregroundStyle(.white.opacity(0.6))
67
+
}
68
+
}
69
+
.clipShape(RoundedRectangle(cornerRadius: 8))
70
+
71
+
VStack(alignment: .leading, spacing: 6) {
72
+
Text("PLAYLIST")
73
+
.font(.system(size: 11, weight: .semibold))
74
+
.foregroundStyle(.secondary)
75
+
Text(playlist.name)
76
+
.font(.system(size: 24, weight: .bold))
77
+
.lineLimit(2)
78
+
if let desc = playlist.description {
79
+
Text(desc)
80
+
.font(.system(size: 12))
81
+
.foregroundStyle(.secondary)
82
+
.lineLimit(2)
83
+
}
84
+
Text("\(tracks.count) tracks · \(formatDuration(totalDuration))")
85
+
.font(.system(size: 12))
86
+
.foregroundStyle(.secondary)
87
+
}
88
+
Spacer()
89
+
}
90
+
.padding(.horizontal, 24)
91
+
.padding(.top, 12)
92
+
93
+
HStack(spacing: 12) {
94
+
Button(action: {
95
+
Task {
96
+
do {
97
+
try await playSavedPlaylist(id: playlist.id)
98
+
await player.fetchQueue()
99
+
} catch {
100
+
errorText = String(describing: error)
101
+
}
102
+
}
103
+
}) {
104
+
Label("Play", systemImage: "play.fill")
105
+
.font(.system(size: 13, weight: .semibold))
106
+
.padding(.horizontal, 20)
107
+
.padding(.vertical, 8)
108
+
.background(Color.accentColor)
109
+
.foregroundStyle(.white)
110
+
.clipShape(Capsule())
111
+
}
112
+
.buttonStyle(.plain)
113
+
114
+
Button(action: { showEditSheet = true }) {
115
+
Label("Edit", systemImage: "pencil")
116
+
.font(.system(size: 13))
117
+
.padding(.horizontal, 16)
118
+
.padding(.vertical, 8)
119
+
.background(Color.secondary.opacity(0.15))
120
+
.clipShape(Capsule())
121
+
}
122
+
.buttonStyle(.plain)
123
+
}
124
+
.padding(.horizontal, 24)
125
+
.padding(.top, 16)
126
+
.padding(.bottom, 20)
127
+
}
128
+
}
129
+
130
+
// Song header
131
+
SongHeaderRow()
132
+
Divider()
133
+
134
+
// Tracks
135
+
LazyVStack(spacing: 0) {
136
+
ForEach(Array(tracks.enumerated()), id: \.element.cuid) { index, song in
137
+
SongRowView(
138
+
song: song,
139
+
index: index + 1,
140
+
isEven: index % 2 == 0,
141
+
showLike: true,
142
+
library: library
143
+
)
144
+
.contextMenu {
145
+
Button(action: {
146
+
Task {
147
+
do {
148
+
try await removeTrackFromSavedPlaylist(
149
+
playlistID: playlist.id,
150
+
trackID: song.cuid
151
+
)
152
+
tracks.remove(at: index)
153
+
} catch {
154
+
errorText = String(describing: error)
155
+
}
156
+
}
157
+
}) {
158
+
Label("Remove from Playlist", systemImage: "minus.circle")
159
+
}
160
+
}
161
+
}
162
+
}
163
+
}
164
+
}
165
+
.sheet(isPresented: $showEditSheet) {
166
+
EditPlaylistSheet(
167
+
isPresented: $showEditSheet,
168
+
initialName: playlist.name,
169
+
initialDescription: playlist.description ?? ""
170
+
) { name, desc in
171
+
Task {
172
+
do {
173
+
try await updateSavedPlaylist(
174
+
id: playlist.id,
175
+
name: name,
176
+
description: desc.isEmpty ? nil : desc
177
+
)
178
+
} catch {
179
+
errorText = String(describing: error)
180
+
}
181
+
}
182
+
}
183
+
}
184
+
.task {
185
+
await loadTracks()
186
+
}
187
+
.alert("Error", isPresented: .constant(errorText != nil)) {
188
+
Button("OK") { errorText = nil }
189
+
} message: {
190
+
Text(errorText ?? "")
191
+
}
192
+
}
193
+
194
+
private func loadTracks() async {
195
+
do {
196
+
let trackIDs = try await fetchSavedPlaylistTracks(playlistID: playlist.id)
197
+
var loaded: [Song] = []
198
+
for id in trackIDs {
199
+
if let track = try? await fetchTrack(id: id) {
200
+
loaded.append(Song(
201
+
cuid: track.id,
202
+
path: track.path,
203
+
title: track.title,
204
+
artist: track.artist,
205
+
album: track.album,
206
+
albumArt: URL(string: "http://localhost:6062/covers/" + track.albumArt),
207
+
duration: TimeInterval(track.length / 1000),
208
+
trackNumber: Int(track.trackNumber),
209
+
discNumber: Int(track.discNumber),
210
+
albumID: track.albumID,
211
+
artistID: track.artistID,
212
+
color: .gray.opacity(0.3)
213
+
))
214
+
}
215
+
}
216
+
tracks = loaded
217
+
} catch {
218
+
errorText = String(describing: error)
219
+
}
220
+
}
221
+
222
+
private func formatDuration(_ d: TimeInterval) -> String {
223
+
let totalMin = Int(d) / 60
224
+
let h = totalMin / 60
225
+
let m = totalMin % 60
226
+
return h > 0 ? "\(h) hr \(m) min" : "\(m) min"
227
+
}
228
+
}
229
+
230
+
struct EditPlaylistSheet: View {
231
+
@Binding var isPresented: Bool
232
+
var initialName: String
233
+
var initialDescription: String
234
+
var onSave: (String, String) -> Void
235
+
236
+
@State private var name = ""
237
+
@State private var desc = ""
238
+
239
+
var body: some View {
240
+
VStack(spacing: 20) {
241
+
Text("Edit Playlist")
242
+
.font(.headline)
243
+
TextField("Name", text: $name)
244
+
.textFieldStyle(.roundedBorder)
245
+
.frame(width: 280)
246
+
TextField("Description (optional)", text: $desc)
247
+
.textFieldStyle(.roundedBorder)
248
+
.frame(width: 280)
249
+
HStack(spacing: 12) {
250
+
Button("Cancel") { isPresented = false }
251
+
.keyboardShortcut(.cancelAction)
252
+
Button("Save") {
253
+
guard !name.trimmingCharacters(in: .whitespaces).isEmpty else { return }
254
+
onSave(name.trimmingCharacters(in: .whitespaces), desc.trimmingCharacters(in: .whitespaces))
255
+
isPresented = false
256
+
}
257
+
.keyboardShortcut(.defaultAction)
258
+
.disabled(name.trimmingCharacters(in: .whitespaces).isEmpty)
259
+
}
260
+
}
261
+
.padding(24)
262
+
.frame(width: 340)
263
+
.onAppear {
264
+
name = initialName
265
+
desc = initialDescription
266
+
}
267
+
}
268
+
}
+165
macos/Rockbox/Views/PlaylistDetail/SmartPlaylistDetailView.swift
+165
macos/Rockbox/Views/PlaylistDetail/SmartPlaylistDetailView.swift
···
1
+
//
2
+
// SmartPlaylistDetailView.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import SwiftUI
7
+
8
+
struct SmartPlaylistDetailView: View {
9
+
let playlist: SmartPlaylist
10
+
@ObservedObject var library: MusicLibrary
11
+
var onBack: () -> Void
12
+
13
+
@EnvironmentObject var player: PlayerState
14
+
@State private var tracks: [Song] = []
15
+
@State private var errorText: String?
16
+
17
+
var totalDuration: TimeInterval {
18
+
tracks.reduce(0) { $0 + $1.duration }
19
+
}
20
+
21
+
var body: some View {
22
+
ScrollView {
23
+
VStack(spacing: 0) {
24
+
// Header
25
+
ZStack(alignment: .topLeading) {
26
+
LinearGradient(
27
+
colors: [Color.purple.opacity(0.35), Color.clear],
28
+
startPoint: .top, endPoint: .bottom
29
+
)
30
+
.frame(height: 220)
31
+
32
+
VStack(alignment: .leading, spacing: 0) {
33
+
Button(action: onBack) {
34
+
HStack(spacing: 4) {
35
+
Image(systemName: "chevron.left")
36
+
Text("Back")
37
+
}
38
+
.font(.system(size: 13))
39
+
.foregroundStyle(.primary)
40
+
}
41
+
.buttonStyle(.plain)
42
+
.padding(.top, 16)
43
+
.padding(.horizontal, 24)
44
+
45
+
HStack(alignment: .bottom, spacing: 20) {
46
+
RoundedRectangle(cornerRadius: 8)
47
+
.fill(Color.purple.opacity(0.25).gradient)
48
+
.frame(width: 120, height: 120)
49
+
.overlay {
50
+
Image(systemName: playlist.isSystem ? "sparkles" : "wand.and.stars")
51
+
.font(.system(size: 40))
52
+
.foregroundStyle(.white.opacity(0.7))
53
+
}
54
+
.clipShape(RoundedRectangle(cornerRadius: 8))
55
+
56
+
VStack(alignment: .leading, spacing: 6) {
57
+
Text(playlist.isSystem ? "SMART PLAYLIST · SYSTEM" : "SMART PLAYLIST")
58
+
.font(.system(size: 11, weight: .semibold))
59
+
.foregroundStyle(.secondary)
60
+
Text(playlist.name)
61
+
.font(.system(size: 24, weight: .bold))
62
+
.lineLimit(2)
63
+
if let desc = playlist.description {
64
+
Text(desc)
65
+
.font(.system(size: 12))
66
+
.foregroundStyle(.secondary)
67
+
.lineLimit(2)
68
+
}
69
+
Text("\(tracks.count) tracks · \(formatDuration(totalDuration))")
70
+
.font(.system(size: 12))
71
+
.foregroundStyle(.secondary)
72
+
}
73
+
Spacer()
74
+
}
75
+
.padding(.horizontal, 24)
76
+
.padding(.top, 12)
77
+
78
+
HStack(spacing: 12) {
79
+
Button(action: {
80
+
Task {
81
+
do {
82
+
try await playSmartPlaylist(id: playlist.id)
83
+
await player.fetchQueue()
84
+
} catch {
85
+
errorText = String(describing: error)
86
+
}
87
+
}
88
+
}) {
89
+
Label("Play", systemImage: "play.fill")
90
+
.font(.system(size: 13, weight: .semibold))
91
+
.padding(.horizontal, 20)
92
+
.padding(.vertical, 8)
93
+
.background(Color.purple.opacity(0.8))
94
+
.foregroundStyle(.white)
95
+
.clipShape(Capsule())
96
+
}
97
+
.buttonStyle(.plain)
98
+
}
99
+
.padding(.horizontal, 24)
100
+
.padding(.top, 16)
101
+
.padding(.bottom, 20)
102
+
}
103
+
}
104
+
105
+
SongHeaderRow()
106
+
Divider()
107
+
108
+
LazyVStack(spacing: 0) {
109
+
ForEach(Array(tracks.enumerated()), id: \.element.cuid) { index, song in
110
+
SongRowView(
111
+
song: song,
112
+
index: index + 1,
113
+
isEven: index % 2 == 0,
114
+
showLike: true,
115
+
library: library
116
+
)
117
+
}
118
+
}
119
+
}
120
+
}
121
+
.task {
122
+
await loadTracks()
123
+
}
124
+
.alert("Error", isPresented: .constant(errorText != nil)) {
125
+
Button("OK") { errorText = nil }
126
+
} message: {
127
+
Text(errorText ?? "")
128
+
}
129
+
}
130
+
131
+
private func loadTracks() async {
132
+
do {
133
+
let trackIDs = try await fetchSmartPlaylistTracks(id: playlist.id)
134
+
var loaded: [Song] = []
135
+
for id in trackIDs {
136
+
if let track = try? await fetchTrack(id: id) {
137
+
loaded.append(Song(
138
+
cuid: track.id,
139
+
path: track.path,
140
+
title: track.title,
141
+
artist: track.artist,
142
+
album: track.album,
143
+
albumArt: URL(string: "http://localhost:6062/covers/" + track.albumArt),
144
+
duration: TimeInterval(track.length / 1000),
145
+
trackNumber: Int(track.trackNumber),
146
+
discNumber: Int(track.discNumber),
147
+
albumID: track.albumID,
148
+
artistID: track.artistID,
149
+
color: .gray.opacity(0.3)
150
+
))
151
+
}
152
+
}
153
+
tracks = loaded
154
+
} catch {
155
+
errorText = String(describing: error)
156
+
}
157
+
}
158
+
159
+
private func formatDuration(_ d: TimeInterval) -> String {
160
+
let totalMin = Int(d) / 60
161
+
let h = totalMin / 60
162
+
let m = totalMin % 60
163
+
return h > 0 ? "\(h) hr \(m) min" : "\(m) min"
164
+
}
165
+
}
+179
macos/Rockbox/Views/Playlists/PlaylistCardView.swift
+179
macos/Rockbox/Views/Playlists/PlaylistCardView.swift
···
1
+
//
2
+
// PlaylistCardView.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import SwiftUI
7
+
8
+
struct PlaylistCardView: View {
9
+
let playlist: SavedPlaylist
10
+
var onSelect: () -> Void
11
+
var onPlay: () -> Void
12
+
var onDelete: () -> Void
13
+
14
+
@State private var isHovering = false
15
+
@State private var isHoveringPlayButton = false
16
+
@State private var showMenu = false
17
+
@State private var isHoveringMenu = false
18
+
19
+
var body: some View {
20
+
VStack(alignment: .leading, spacing: 8) {
21
+
RoundedRectangle(cornerRadius: 5)
22
+
.fill(Color.gray.opacity(0.3).gradient)
23
+
.aspectRatio(1, contentMode: .fit)
24
+
.overlay {
25
+
if let imageURL = playlist.image, !imageURL.isEmpty {
26
+
CachedAsyncImage(url: URL(string: "http://localhost:6062/covers/" + imageURL)) { phase in
27
+
switch phase {
28
+
case .success(let image):
29
+
image.resizable().aspectRatio(contentMode: .fill)
30
+
default:
31
+
Image(systemName: "music.note.list")
32
+
.font(.system(size: 40))
33
+
.foregroundStyle(.white.opacity(0.6))
34
+
}
35
+
}
36
+
} else {
37
+
Image(systemName: "music.note.list")
38
+
.font(.system(size: 40))
39
+
.foregroundStyle(.white.opacity(0.6))
40
+
}
41
+
}
42
+
.overlay(alignment: .bottom) {
43
+
if isHovering || showMenu {
44
+
HStack(spacing: 0) {
45
+
Button(action: onPlay) {
46
+
Circle()
47
+
.fill(isHoveringPlayButton ? Color(hex: "fe09a3") : .white.opacity(0.3))
48
+
.frame(width: 36, height: 36)
49
+
.overlay {
50
+
Image(systemName: "play.fill")
51
+
.font(.system(size: 14))
52
+
.foregroundStyle(.white)
53
+
}
54
+
}
55
+
.buttonStyle(.borderless)
56
+
.onHover { isHoveringPlayButton = $0 }
57
+
.frame(maxWidth: .infinity, alignment: .center)
58
+
59
+
ZStack {
60
+
Circle()
61
+
.fill(isHoveringMenu || showMenu ? Color(hex: "fe09a3") : .white.opacity(0.3))
62
+
.frame(width: 36, height: 36)
63
+
Image(systemName: "ellipsis")
64
+
.font(.system(size: 14, weight: .medium))
65
+
.foregroundStyle(.white)
66
+
.allowsHitTesting(false)
67
+
Button(action: { showMenu.toggle() }) {
68
+
Circle().fill(Color.clear).frame(width: 36, height: 36)
69
+
}
70
+
.buttonStyle(.borderless)
71
+
.onHover { isHoveringMenu = $0 }
72
+
.popover(isPresented: $showMenu, arrowEdge: .bottom) {
73
+
ZStack {
74
+
Color.white.ignoresSafeArea()
75
+
VStack(alignment: .leading, spacing: 0) {
76
+
MenuItemButton(title: "Play", icon: "play.fill") {
77
+
showMenu = false; onPlay()
78
+
}
79
+
Divider().padding(.vertical, 4)
80
+
MenuItemButton(title: "Delete", icon: "trash") {
81
+
showMenu = false; onDelete()
82
+
}
83
+
}
84
+
.padding(8)
85
+
.frame(width: 180)
86
+
}
87
+
}
88
+
}
89
+
.frame(maxWidth: .infinity, alignment: .center)
90
+
}
91
+
.padding(.vertical, 12)
92
+
.transition(.opacity.combined(with: .move(edge: .bottom)))
93
+
}
94
+
}
95
+
.clipShape(RoundedRectangle(cornerRadius: 5))
96
+
.onTapGesture { onSelect() }
97
+
.onHover { hovering in
98
+
withAnimation(.easeInOut(duration: 0.2)) {
99
+
if !showMenu { isHovering = hovering }
100
+
}
101
+
}
102
+
.onChange(of: showMenu) { _, newValue in
103
+
if !newValue {
104
+
withAnimation(.easeInOut(duration: 0.2)) { isHovering = false }
105
+
}
106
+
}
107
+
108
+
VStack(alignment: .leading, spacing: 2) {
109
+
Text(playlist.name)
110
+
.font(.system(size: 12, weight: .medium))
111
+
.lineLimit(1)
112
+
Text("\(playlist.trackCount) tracks")
113
+
.font(.system(size: 11))
114
+
.foregroundStyle(.secondary)
115
+
.lineLimit(1)
116
+
}
117
+
.onTapGesture { onSelect() }
118
+
}
119
+
}
120
+
}
121
+
122
+
struct SmartPlaylistCardView: View {
123
+
let playlist: SmartPlaylist
124
+
var onSelect: () -> Void
125
+
var onPlay: () -> Void
126
+
127
+
@State private var isHovering = false
128
+
@State private var isHoveringPlayButton = false
129
+
130
+
var body: some View {
131
+
VStack(alignment: .leading, spacing: 8) {
132
+
RoundedRectangle(cornerRadius: 5)
133
+
.fill(Color.purple.opacity(0.25).gradient)
134
+
.aspectRatio(1, contentMode: .fit)
135
+
.overlay {
136
+
Image(systemName: playlist.isSystem ? "sparkles" : "wand.and.stars")
137
+
.font(.system(size: 40))
138
+
.foregroundStyle(.white.opacity(0.7))
139
+
}
140
+
.overlay(alignment: .bottom) {
141
+
if isHovering {
142
+
HStack(spacing: 0) {
143
+
Button(action: onPlay) {
144
+
Circle()
145
+
.fill(isHoveringPlayButton ? Color(hex: "fe09a3") : .white.opacity(0.3))
146
+
.frame(width: 36, height: 36)
147
+
.overlay {
148
+
Image(systemName: "play.fill")
149
+
.font(.system(size: 14))
150
+
.foregroundStyle(.white)
151
+
}
152
+
}
153
+
.buttonStyle(.borderless)
154
+
.onHover { isHoveringPlayButton = $0 }
155
+
.frame(maxWidth: .infinity, alignment: .center)
156
+
}
157
+
.padding(.vertical, 12)
158
+
.transition(.opacity.combined(with: .move(edge: .bottom)))
159
+
}
160
+
}
161
+
.clipShape(RoundedRectangle(cornerRadius: 5))
162
+
.onTapGesture { onSelect() }
163
+
.onHover { hovering in
164
+
withAnimation(.easeInOut(duration: 0.2)) { isHovering = hovering }
165
+
}
166
+
167
+
VStack(alignment: .leading, spacing: 2) {
168
+
Text(playlist.name)
169
+
.font(.system(size: 12, weight: .medium))
170
+
.lineLimit(1)
171
+
Text(playlist.isSystem ? "Smart · System" : "Smart")
172
+
.font(.system(size: 11))
173
+
.foregroundStyle(.secondary)
174
+
.lineLimit(1)
175
+
}
176
+
.onTapGesture { onSelect() }
177
+
}
178
+
}
179
+
}
+200
macos/Rockbox/Views/Playlists/PlaylistsView.swift
+200
macos/Rockbox/Views/Playlists/PlaylistsView.swift
···
1
+
//
2
+
// PlaylistsView.swift
3
+
// Rockbox
4
+
//
5
+
6
+
import SwiftUI
7
+
8
+
struct PlaylistsView: View {
9
+
@EnvironmentObject var navigation: NavigationManager
10
+
@EnvironmentObject var player: PlayerState
11
+
12
+
@State private var savedPlaylists: [SavedPlaylist] = []
13
+
@State private var smartPlaylists: [SmartPlaylist] = []
14
+
@State private var errorText: String?
15
+
@State private var showCreateSheet = false
16
+
@State private var newPlaylistName = ""
17
+
@State private var isCreating = false
18
+
19
+
private let columns = [GridItem(.adaptive(minimum: 170, maximum: 230), spacing: 20)]
20
+
21
+
var body: some View {
22
+
ScrollView {
23
+
VStack(alignment: .leading, spacing: 24) {
24
+
if !smartPlaylists.isEmpty {
25
+
VStack(alignment: .leading, spacing: 12) {
26
+
Text("Smart Playlists")
27
+
.font(.system(size: 13, weight: .semibold))
28
+
.foregroundStyle(.secondary)
29
+
.padding(.horizontal, 20)
30
+
31
+
LazyVGrid(columns: columns, spacing: 24) {
32
+
ForEach(smartPlaylists) { pl in
33
+
SmartPlaylistCardView(
34
+
playlist: pl,
35
+
onSelect: { navigation.goToSmartPlaylist(pl) },
36
+
onPlay: {
37
+
Task {
38
+
do {
39
+
try await playSmartPlaylist(id: pl.id)
40
+
await player.fetchQueue()
41
+
} catch {
42
+
errorText = String(describing: error)
43
+
}
44
+
}
45
+
}
46
+
)
47
+
}
48
+
}
49
+
.padding(.horizontal, 20)
50
+
}
51
+
}
52
+
53
+
VStack(alignment: .leading, spacing: 12) {
54
+
HStack {
55
+
Text("Saved Playlists")
56
+
.font(.system(size: 13, weight: .semibold))
57
+
.foregroundStyle(.secondary)
58
+
Spacer()
59
+
Button(action: { showCreateSheet = true }) {
60
+
Label("New Playlist", systemImage: "plus")
61
+
.font(.system(size: 12))
62
+
}
63
+
.buttonStyle(.bordered)
64
+
}
65
+
.padding(.horizontal, 20)
66
+
67
+
if savedPlaylists.isEmpty {
68
+
VStack(spacing: 8) {
69
+
Image(systemName: "music.note.list")
70
+
.font(.system(size: 36))
71
+
.foregroundStyle(.secondary)
72
+
Text("No playlists yet")
73
+
.font(.system(size: 13))
74
+
.foregroundStyle(.secondary)
75
+
}
76
+
.frame(maxWidth: .infinity)
77
+
.padding(.top, 40)
78
+
} else {
79
+
LazyVGrid(columns: columns, spacing: 24) {
80
+
ForEach(savedPlaylists) { pl in
81
+
PlaylistCardView(
82
+
playlist: pl,
83
+
onSelect: { navigation.goToPlaylist(pl) },
84
+
onPlay: {
85
+
Task {
86
+
do {
87
+
try await playSavedPlaylist(id: pl.id)
88
+
await player.fetchQueue()
89
+
} catch {
90
+
errorText = String(describing: error)
91
+
}
92
+
}
93
+
},
94
+
onDelete: {
95
+
Task {
96
+
do {
97
+
try await deleteSavedPlaylist(id: pl.id)
98
+
savedPlaylists.removeAll { $0.id == pl.id }
99
+
} catch {
100
+
errorText = String(describing: error)
101
+
}
102
+
}
103
+
}
104
+
)
105
+
}
106
+
}
107
+
.padding(.horizontal, 20)
108
+
}
109
+
}
110
+
}
111
+
.padding(.vertical, 20)
112
+
}
113
+
.sheet(isPresented: $showCreateSheet) {
114
+
CreatePlaylistSheet(isPresented: $showCreateSheet) { name in
115
+
Task {
116
+
do {
117
+
isCreating = true
118
+
let pl = try await createSavedPlaylist(name: name)
119
+
let saved = SavedPlaylist(
120
+
id: pl.id, name: pl.name,
121
+
description: pl.hasDescription_p ? pl.description_p : nil,
122
+
image: pl.hasImage ? pl.image : nil,
123
+
folderID: pl.hasFolderID ? pl.folderID : nil,
124
+
trackCount: pl.trackCount
125
+
)
126
+
savedPlaylists.append(saved)
127
+
isCreating = false
128
+
} catch {
129
+
isCreating = false
130
+
errorText = String(describing: error)
131
+
}
132
+
}
133
+
}
134
+
}
135
+
.task {
136
+
await loadPlaylists()
137
+
}
138
+
.alert("Error", isPresented: .constant(errorText != nil)) {
139
+
Button("OK") { errorText = nil }
140
+
} message: {
141
+
Text(errorText ?? "")
142
+
}
143
+
}
144
+
145
+
private func loadPlaylists() async {
146
+
do {
147
+
async let saved = fetchSavedPlaylists()
148
+
async let smart = fetchSmartPlaylists()
149
+
let (savedData, smartData) = try await (saved, smart)
150
+
savedPlaylists = savedData.map {
151
+
SavedPlaylist(
152
+
id: $0.id, name: $0.name,
153
+
description: $0.hasDescription_p ? $0.description_p : nil,
154
+
image: $0.hasImage ? $0.image : nil,
155
+
folderID: $0.hasFolderID ? $0.folderID : nil,
156
+
trackCount: $0.trackCount
157
+
)
158
+
}
159
+
smartPlaylists = smartData.map {
160
+
SmartPlaylist(
161
+
id: $0.id, name: $0.name,
162
+
description: $0.hasDescription_p ? $0.description_p : nil,
163
+
image: $0.hasImage ? $0.image : nil,
164
+
isSystem: $0.isSystem
165
+
)
166
+
}
167
+
} catch {
168
+
errorText = String(describing: error)
169
+
}
170
+
}
171
+
}
172
+
173
+
struct CreatePlaylistSheet: View {
174
+
@Binding var isPresented: Bool
175
+
var onCreate: (String) -> Void
176
+
@State private var name = ""
177
+
178
+
var body: some View {
179
+
VStack(spacing: 20) {
180
+
Text("New Playlist")
181
+
.font(.headline)
182
+
TextField("Name", text: $name)
183
+
.textFieldStyle(.roundedBorder)
184
+
.frame(width: 280)
185
+
HStack(spacing: 12) {
186
+
Button("Cancel") { isPresented = false }
187
+
.keyboardShortcut(.cancelAction)
188
+
Button("Create") {
189
+
guard !name.trimmingCharacters(in: .whitespaces).isEmpty else { return }
190
+
onCreate(name.trimmingCharacters(in: .whitespaces))
191
+
isPresented = false
192
+
}
193
+
.keyboardShortcut(.defaultAction)
194
+
.disabled(name.trimmingCharacters(in: .whitespaces).isEmpty)
195
+
}
196
+
}
197
+
.padding(24)
198
+
.frame(width: 340)
199
+
}
200
+
}
+46
-10
macos/Rockbox/Views/Search/SearchResultsView.swift
+46
-10
macos/Rockbox/Views/Search/SearchResultsView.swift
···
12
12
@EnvironmentObject var navigation: NavigationManager
13
13
@EnvironmentObject var player: PlayerState
14
14
@ObservedObject var library: MusicLibrary
15
-
var playlists: [Playlist] = []
15
+
@State private var savedPlaylists: [SavedPlaylist] = []
16
16
17
17
var body: some View {
18
18
ScrollView {
···
43
43
ScrollView(.horizontal, showsIndicators: false) {
44
44
HStack(spacing: 16) {
45
45
ForEach(searchManager.searchResults.albums) { album in
46
-
SearchAlbumCard(album: album, playlists: playlists) {
46
+
SearchAlbumCard(album: album, savedPlaylists: savedPlaylists) {
47
47
navigation.goToAlbum(album)
48
48
searchManager.clear()
49
49
}
···
63
63
song: song,
64
64
index: index,
65
65
library: library,
66
-
playlists: playlists
66
+
savedPlaylists: savedPlaylists
67
67
)
68
68
}
69
69
}
···
74
74
}
75
75
.padding(.vertical, 20)
76
76
}
77
+
.task {
78
+
if savedPlaylists.isEmpty {
79
+
if let data = try? await fetchSavedPlaylists() {
80
+
savedPlaylists = data.map {
81
+
SavedPlaylist(
82
+
id: $0.id, name: $0.name,
83
+
description: $0.hasDescription_p ? $0.description_p : nil,
84
+
image: $0.hasImage ? $0.image : nil,
85
+
folderID: $0.hasFolderID ? $0.folderID : nil,
86
+
trackCount: $0.trackCount
87
+
)
88
+
}
89
+
}
90
+
}
91
+
}
77
92
}
78
-
93
+
79
94
private var emptyResultsView: some View {
80
95
VStack(spacing: 12) {
81
96
Image(systemName: "magnifyingglass")
···
200
215
201
216
struct SearchAlbumCard: View {
202
217
let album: Album
203
-
var playlists: [Playlist] = []
218
+
var savedPlaylists: [SavedPlaylist] = []
204
219
let onSelect: () -> Void
205
220
206
221
@State private var isHovering = false
···
319
334
title: "Add to Playlist",
320
335
icon: "music.note.list",
321
336
hasSubmenu: true,
322
-
submenuItems: playlists,
337
+
savedPlaylists: savedPlaylists,
323
338
onSubmenuSelect: { playlist in
324
339
showMenu = false
340
+
Task {
341
+
do {
342
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
343
+
try await addTracksToSavedPlaylist(
344
+
playlistID: playlist.id,
345
+
trackIDs: tracks.map { $0.id })
346
+
} catch {}
347
+
}
325
348
},
326
349
onCreateNew: {
327
350
showMenu = false
351
+
Task {
352
+
do {
353
+
let tracks = try await fetchAlbumTracks(albumID: album.cuid)
354
+
let _ = try await createSavedPlaylist(
355
+
name: album.title,
356
+
trackIDs: tracks.map { $0.id })
357
+
} catch {}
358
+
}
328
359
},
329
360
action: {}
330
361
)
···
385
416
let song: Song
386
417
let index: Int
387
418
@ObservedObject var library: MusicLibrary
388
-
var playlists: [Playlist] = []
419
+
var savedPlaylists: [SavedPlaylist] = []
389
420
390
421
@State private var isHovering = false
391
422
@State private var isHoveringPlay = false
···
507
538
title: "Add to Playlist",
508
539
icon: "music.note.list",
509
540
hasSubmenu: true,
510
-
submenuItems: playlists,
541
+
savedPlaylists: savedPlaylists,
511
542
onSubmenuSelect: { playlist in
512
-
// Add to playlist
543
+
Task {
544
+
try? await addTracksToSavedPlaylist(
545
+
playlistID: playlist.id, trackIDs: [song.cuid])
546
+
}
513
547
},
514
548
onCreateNew: {
515
-
// Create new playlist
549
+
Task {
550
+
try? await createSavedPlaylist(name: song.title, trackIDs: [song.cuid])
551
+
}
516
552
},
517
553
action: {}
518
554
)
+54
-9
macos/Rockbox/Views/Songs/SongRowView.swift
+54
-9
macos/Rockbox/Views/Songs/SongRowView.swift
···
17
17
@ObservedObject var library: MusicLibrary
18
18
@EnvironmentObject var player: PlayerState
19
19
@EnvironmentObject var navigation: NavigationManager
20
-
20
+
21
21
@State private var isHovering = false
22
22
@State private var isHoveringMenu = false
23
+
@State private var savedPlaylists: [SavedPlaylist] = []
23
24
24
25
var body: some View {
25
26
HStack(spacing: 12) {
···
128
129
Label("Play Next", systemImage: "text.insert")
129
130
}
130
131
131
-
Button(action: {
132
-
Task {
133
-
do {
134
-
// Add to playlist
135
-
} catch {
136
-
errorText = String(describing: error)
132
+
Menu {
133
+
Button(action: {
134
+
Task {
135
+
do {
136
+
let pl = try await createSavedPlaylist(name: song.title, trackIDs: [song.cuid])
137
+
let saved = SavedPlaylist(
138
+
id: pl.id, name: pl.name,
139
+
description: nil, image: nil, folderID: nil,
140
+
trackCount: pl.trackCount
141
+
)
142
+
savedPlaylists.append(saved)
143
+
} catch {
144
+
errorText = String(describing: error)
145
+
}
146
+
}
147
+
}) {
148
+
Label("New Playlist...", systemImage: "plus")
149
+
}
150
+
if !savedPlaylists.isEmpty {
151
+
Divider()
152
+
ForEach(savedPlaylists) { pl in
153
+
Button(action: {
154
+
Task {
155
+
do {
156
+
try await addTracksToSavedPlaylist(
157
+
playlistID: pl.id, trackIDs: [song.cuid])
158
+
} catch {
159
+
errorText = String(describing: error)
160
+
}
161
+
}
162
+
}) {
163
+
Label(pl.name, systemImage: "music.note.list")
164
+
}
137
165
}
138
166
}
139
-
}) {
167
+
} label: {
140
168
Label("Add to Playlist", systemImage: "text.append")
141
169
}
142
-
170
+
.menuStyle(.borderlessButton)
171
+
.menuIndicator(.hidden)
172
+
143
173
Button(action: {
144
174
Task {
145
175
do {
···
202
232
.onHover { hovering in
203
233
withAnimation(.easeInOut(duration: 0.15)) {
204
234
isHovering = hovering
235
+
}
236
+
}
237
+
.task {
238
+
if savedPlaylists.isEmpty {
239
+
if let data = try? await fetchSavedPlaylists() {
240
+
savedPlaylists = data.map {
241
+
SavedPlaylist(
242
+
id: $0.id, name: $0.name,
243
+
description: $0.hasDescription_p ? $0.description_p : nil,
244
+
image: $0.hasImage ? $0.image : nil,
245
+
folderID: $0.hasFolderID ? $0.folderID : nil,
246
+
trackCount: $0.trackCount
247
+
)
248
+
}
249
+
}
205
250
}
206
251
}
207
252
.alert("Error", isPresented: .constant(errorText != nil)) {