darkbio_wire/protocol/generated/
darkbio.wire.rs

1// This file is @generated by prost-build.
2/// HostToArk represents a message sent from the host to the Ark via the USB
3/// connection. It embeds all possible message types to keep the protocol simple.
4///
5/// Every message carries an id and is either a request, its id chosen by the
6/// host, or the host's response to a request of the Ark, echoing the Ark's id.
7/// To avoid id collisions, hosts allocate odd ids and Arks even ones, so the
8/// parity of the id alone distinguishes a response from a request.
9#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
10pub struct HostToArk {
11    /// Enveloping fields, reserved range 0x001-0x0ff
12    ///
13    /// Request identifier, the host's own or responded to
14    #[prost(uint64, tag = "1")]
15    pub id: u64,
16    /// Error encountered while serving the Ark's request (if any)
17    #[prost(message, optional, tag = "2")]
18    pub err: ::core::option::Option<Error>,
19    /// Body of the message, a request of the host or its response to a request of
20    /// the Ark. The tags are grouped by area, each area with its own range.
21    #[prost(
22        oneof = "host_to_ark::Content",
23        tags = "256, 257, 258, 259, 260, 513, 514, 515, 516, 517, 769, 770, 771, 772, 773, 774, 1025, 1026, 1027, 1281, 1282, 1283, 1284, 1285, 1286, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1793, 4096"
24    )]
25    pub content: ::core::option::Option<host_to_ark::Content>,
26}
27/// Nested message and enum types in `HostToArk`.
28pub mod host_to_ark {
29    /// Body of the message, a request of the host or its response to a request of
30    /// the Ark. The tags are grouped by area, each area with its own range.
31    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
32    pub enum Content {
33        /// Installs the signed device attestation at manufacturing
34        #[prost(message, tag = "256")]
35        Onboard(super::OnboardingRequest),
36        /// Fetches the hardware and firmware versions
37        #[prost(message, tag = "257")]
38        DeviceInfo(super::DeviceInfoRequest),
39        /// Starts a cloud sync with the attested cloud keys
40        #[prost(message, tag = "258")]
41        CloudSyncStart(super::CloudSyncStartRequest),
42        /// Finishes a cloud sync with the signed server time
43        #[prost(message, tag = "259")]
44        CloudSyncFinish(super::CloudSyncFinishRequest),
45        /// Requests a proof of the device's genuinity
46        #[prost(message, tag = "260")]
47        GenuinityProof(super::GenuinityProofRequest),
48        /// Prepares an update, aborting any in progress
49        #[prost(message, tag = "513")]
50        FirmwareUpdatePrep(super::FirmwareUpdatePrepRequest),
51        /// Initiates a prepared update with the sealed firmware key
52        #[prost(message, tag = "514")]
53        FirmwareUpdateInit(super::FirmwareUpdateInitRequest),
54        /// Appends a chunk of the firmware archive
55        #[prost(message, tag = "515")]
56        FirmwareUpdateUpload(super::FirmwareUpdateUploadRequest),
57        /// Decrypts and verifies the uploaded firmware
58        #[prost(message, tag = "516")]
59        FirmwareUpdateVerify(super::FirmwareUpdateVerifyRequest),
60        /// Installs the verified firmware and reboots
61        #[prost(message, tag = "517")]
62        FirmwareUpdateInstall(super::FirmwareUpdateInstallRequest),
63        /// Asks the Ark to authorize a pairing rendezvous
64        #[prost(message, tag = "769")]
65        PairingAuth(super::PairingAuthRequest),
66        /// Injects the companion app's identity, relayed by the cloud
67        #[prost(message, tag = "770")]
68        PairingSetAppId(super::PairingSetAppIdentityRequest),
69        /// Injects the companion app's storage key material
70        #[prost(message, tag = "771")]
71        PairingSetAppStorage(super::PairingSetAppStorageRequest),
72        /// Confirms the app received the Ark's key material
73        #[prost(message, tag = "772")]
74        PairingAckArkStorage(super::PairingAckArkStorageRequest),
75        /// Waits for the user to accept the pairing
76        #[prost(message, tag = "773")]
77        PairingAccept(super::PairingAcceptanceRequest),
78        /// Waits for the Ark to finish pairing maintenance
79        #[prost(message, tag = "774")]
80        PairingComplete(super::PairingCompletionRequest),
81        /// Asks the Ark to authorize joining the app relay
82        #[prost(message, tag = "1025")]
83        RelayJoin(super::RelayJoinRequest),
84        /// Forwards one frame from the relay socket to the Ark
85        #[prost(message, tag = "1026")]
86        RelayInbound(super::RelayInboundRequest),
87        /// Confirms the relay socket accepted the frame
88        #[prost(message, tag = "1027")]
89        RelayOutbound(super::RelayOutboundResponse),
90        /// Starts the unlock, confirmed through the app
91        #[prost(message, tag = "1281")]
92        Unlock(super::UnlockRequest),
93        /// Begins a chunked upload of an app to execute
94        #[prost(message, tag = "1282")]
95        ExecUploadStart(super::ExecutionUploadStartRequest),
96        /// Appends a chunk to a pending app upload
97        #[prost(message, tag = "1283")]
98        ExecUploadChunk(super::ExecutionUploadChunkRequest),
99        /// Runs an uploaded app, confirmed through the app
100        #[prost(message, tag = "1284")]
101        ExecSched(super::ExecutionScheduleRequest),
102        /// Checks on a running app
103        #[prost(message, tag = "1285")]
104        ExecStatus(super::ExecutionStatusRequest),
105        /// Cancels an app run or a pending upload
106        #[prost(message, tag = "1286")]
107        ExecCancel(super::ExecutionCancelRequest),
108        /// Lists the state of every data slot
109        #[prost(message, tag = "1537")]
110        SlotList(super::SlotListRequest),
111        /// Resets a slot to empty whatever its state
112        #[prost(message, tag = "1538")]
113        SlotRepair(super::SlotRepairRequest),
114        /// Removes the contents of a filled slot
115        #[prost(message, tag = "1539")]
116        SlotDelete(super::SlotDeleteRequest),
117        /// Asks the Ark to identify a file from its first chunk
118        #[prost(message, tag = "1540")]
119        SlotIdentify(super::SlotIdentifyRequest),
120        /// Starts uploading a file into a slot
121        #[prost(message, tag = "1541")]
122        SlotUploadStart(super::SlotUploadStartRequest),
123        /// Appends a chunk to a pending slot upload
124        #[prost(message, tag = "1542")]
125        SlotUploadChunk(super::SlotUploadChunkRequest),
126        /// Aborts a pending slot upload
127        #[prost(message, tag = "1543")]
128        SlotUploadCancel(super::SlotUploadCancelRequest),
129        /// Marks an upload complete and polls its processing
130        #[prost(message, tag = "1544")]
131        SlotUploadProcess(super::SlotUploadProcessRequest),
132        /// Maps every path an app can read, from the dataset view
133        #[prost(message, tag = "1793")]
134        DatasetPaths(super::DatasetPathsRequest),
135        /// Unreleased messages served by development firmware only, carried opaquely
136        /// so the public protocol is untouched while they are still under development.
137        /// Their schema is private and production Arks refuse the envelope.
138        #[prost(bytes, tag = "4096")]
139        Develop(::prost::alloc::vec::Vec<u8>),
140    }
141}
142/// ArkToHost represents a message sent from the Ark to the host via the USB
143/// connection. It embeds all possible message types to keep the protocol simple.
144///
145/// Every message carries an id and is either a request, its id chosen by the
146/// Ark, or the Ark's response to a request of the host, echoing the host's id.
147/// To avoid id collisions, hosts allocate odd ids and Arks even ones, so the
148/// parity of the id alone distinguishes a response from a request.
149#[derive(Clone, PartialEq, ::prost::Message)]
150pub struct ArkToHost {
151    /// Enveloping fields, reserved range 0x001-0x0ff
152    ///
153    /// Request identifier, responded to or the Ark's own
154    #[prost(uint64, tag = "1")]
155    pub id: u64,
156    /// Error encountered while serving the host's request (if any)
157    #[prost(message, optional, tag = "2")]
158    pub err: ::core::option::Option<Error>,
159    /// Body of the message, a response of the Ark to a request of the host or a
160    /// request of its own. The tags are grouped by area, each area with its own range.
161    #[prost(
162        oneof = "ark_to_host::Content",
163        tags = "256, 257, 258, 259, 260, 513, 514, 515, 516, 517, 769, 770, 771, 772, 773, 774, 1025, 1026, 1027, 1281, 1282, 1283, 1284, 1285, 1286, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1793, 4096"
164    )]
165    pub content: ::core::option::Option<ark_to_host::Content>,
166}
167/// Nested message and enum types in `ArkToHost`.
168pub mod ark_to_host {
169    /// Body of the message, a response of the Ark to a request of the host or a
170    /// request of its own. The tags are grouped by area, each area with its own range.
171    #[derive(Clone, PartialEq, ::prost::Oneof)]
172    pub enum Content {
173        /// Acknowledges the onboarding
174        #[prost(message, tag = "256")]
175        Onboard(super::OnboardingResponse),
176        /// Hardware and firmware versions of the Ark
177        #[prost(message, tag = "257")]
178        DeviceInfo(super::DeviceInfoResponse),
179        /// Challenge for the cloud to sign along its time
180        #[prost(message, tag = "258")]
181        CloudSyncStart(super::CloudSyncStartResponse),
182        /// Timestamp the Ark accepted from the cloud
183        #[prost(message, tag = "259")]
184        CloudSyncFinish(super::CloudSyncFinishResponse),
185        /// Encrypted proof of the Ark's genuinity for the cloud
186        #[prost(message, tag = "260")]
187        GenuinityProof(super::GenuinityProofResponse),
188        /// Ephemeral key to receive the firmware key with, sealed for the cloud
189        #[prost(message, tag = "513")]
190        FirmwareUpdatePrep(super::FirmwareUpdatePrepResponse),
191        /// Acknowledges the initiated update
192        #[prost(message, tag = "514")]
193        FirmwareUpdateInit(super::FirmwareUpdateInitResponse),
194        /// Acknowledges the appended firmware chunk
195        #[prost(message, tag = "515")]
196        FirmwareUpdateUpload(super::FirmwareUpdateUploadResponse),
197        /// Acknowledges the verified firmware
198        #[prost(message, tag = "516")]
199        FirmwareUpdateVerify(super::FirmwareUpdateVerifyResponse),
200        /// Acknowledges the installed firmware
201        #[prost(message, tag = "517")]
202        FirmwareUpdateInstall(super::FirmwareUpdateInstallResponse),
203        /// Signed authorization for the cloud to open a rendezvous
204        #[prost(message, tag = "769")]
205        PairingAuth(super::PairingAuthResponse),
206        /// Acknowledges the accepted app identity
207        #[prost(message, tag = "770")]
208        PairingSetAppId(super::PairingSetAppIdentityResponse),
209        /// Ark device infos and key material, sealed for the app
210        #[prost(message, tag = "771")]
211        PairingSetAppStorage(super::PairingSetAppStorageResponse),
212        /// Acknowledges the app's receipt of the Ark's keys
213        #[prost(message, tag = "772")]
214        PairingAckArkStorage(super::PairingAckArkStorageResponse),
215        /// Signed confirmation that the user accepted the pairing
216        #[prost(message, tag = "773")]
217        PairingAccept(super::PairingAcceptanceResponse),
218        /// Signed confirmation that the Ark finished pairing
219        #[prost(message, tag = "774")]
220        PairingComplete(super::PairingCompletionResponse),
221        /// Signed authorization for the cloud to join the relay
222        #[prost(message, tag = "1025")]
223        RelayJoin(super::RelayJoinResponse),
224        /// Confirms the Ark opened the frame
225        #[prost(message, tag = "1026")]
226        RelayInbound(super::RelayInboundResponse),
227        /// Asks the host to write one frame to its relay socket
228        #[prost(message, tag = "1027")]
229        RelayOutbound(super::RelayOutboundRequest),
230        /// Acknowledges the completed unlock
231        #[prost(message, tag = "1281")]
232        Unlock(super::UnlockResponse),
233        /// Task id for the chunk, schedule and cancel messages
234        #[prost(message, tag = "1282")]
235        ExecUploadStart(super::ExecutionUploadStartResponse),
236        /// Acknowledges the appended app chunk
237        #[prost(message, tag = "1283")]
238        ExecUploadChunk(super::ExecutionUploadChunkResponse),
239        /// Acknowledges the authorized and started execution
240        #[prost(message, tag = "1284")]
241        ExecSched(super::ExecutionScheduleResponse),
242        /// Whether the app still runs, with its result once done
243        #[prost(message, tag = "1285")]
244        ExecStatus(super::ExecutionStatusResponse),
245        /// Acknowledges the canceled run or upload
246        #[prost(message, tag = "1286")]
247        ExecCancel(super::ExecutionCancelResponse),
248        /// Current state of every data slot
249        #[prost(message, tag = "1537")]
250        SlotList(super::SlotListResponse),
251        /// Acknowledges the reset slot
252        #[prost(message, tag = "1538")]
253        SlotRepair(super::SlotRepairResponse),
254        /// Acknowledges the deleted slot
255        #[prost(message, tag = "1539")]
256        SlotDelete(super::SlotDeleteResponse),
257        /// Identification of the file's first chunk
258        #[prost(message, tag = "1540")]
259        SlotIdentify(super::SlotIdentifyResponse),
260        /// Session id of the approved upload
261        #[prost(message, tag = "1541")]
262        SlotUploadStart(super::SlotUploadStartResponse),
263        /// Acknowledges the appended slot chunk
264        #[prost(message, tag = "1542")]
265        SlotUploadChunk(super::SlotUploadChunkResponse),
266        /// Acknowledges the aborted upload
267        #[prost(message, tag = "1543")]
268        SlotUploadCancel(super::SlotUploadCancelResponse),
269        /// Processing progress of the completed upload
270        #[prost(message, tag = "1544")]
271        SlotUploadProcess(super::SlotUploadProcessResponse),
272        /// Every path an app can read, with its description, format and examples
273        #[prost(message, tag = "1793")]
274        DatasetPaths(super::DatasetPathsResponse),
275        /// Unreleased messages emitted by development firmware only, in response to
276        /// a develop request, carried opaquely so the public protocol is untouched
277        /// while they are still under development. Their schema is private.
278        #[prost(bytes, tag = "4096")]
279        Develop(::prost::alloc::vec::Vec<u8>),
280    }
281}
282/// Error answers a failed request, in place of the response content.
283///
284/// Codes 0x00 through 0xff (inclusive) are reserved for protocol-wide errors.
285/// Codes 0x100 and above are defined by the request type and may be reused
286/// with different meanings for different requests. The message text is human
287/// readable, not a stable code.
288#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
289pub struct Error {
290    /// Error code for programmatic interpretation
291    #[prost(uint64, tag = "1")]
292    pub code: u64,
293    /// Error message for user interfacing
294    #[prost(string, tag = "2")]
295    pub msg: ::prost::alloc::string::String,
296}
297/// OnboardingRequest is a vendor utility to onboard an Ark. Currently it contains
298/// the signed device genuinity attestation (certificate).
299///
300/// Note, as this method is only used during initial device setup, there is no API
301/// compatibility guarantee, it will evolve with the factory tooling.
302#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
303pub struct OnboardingRequest {
304    /// Signed device genuinity attestation (CWT) to install
305    #[prost(bytes = "vec", tag = "1")]
306    pub device_attestation: ::prost::alloc::vec::Vec<u8>,
307}
308/// OnboardingResponse is the acknowledgement of the onboarding.
309#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
310pub struct OnboardingResponse {}
311/// DeviceInfoRequest is sent by the host to fetch the Ark's device stats.
312#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
313pub struct DeviceInfoRequest {}
314/// DeviceInfoResponse returns various hardware and software version information.
315#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
316pub struct DeviceInfoResponse {
317    /// Ark device version (defines the major features)
318    #[prost(uint32, tag = "1")]
319    pub version_id: u32,
320    /// Ark device version label (as known by the device)
321    #[prost(string, tag = "2")]
322    pub version_str: ::prost::alloc::string::String,
323    /// Ark device revision (defines the minor differences)
324    #[prost(uint32, tag = "3")]
325    pub revision_id: u32,
326    /// Ark device revision label (as known by the device)
327    #[prost(string, tag = "4")]
328    pub revision_str: ::prost::alloc::string::String,
329    /// Current firmware version (X.Y.Z-commit)
330    #[prost(string, tag = "7")]
331    pub firmware_version: ::prost::alloc::string::String,
332    /// Current firmware publish unix timestamp
333    #[prost(uint64, tag = "8")]
334    pub firmware_publish: u64,
335    /// Whether a cloud identity was accepted since boot
336    #[prost(bool, tag = "9")]
337    pub cloud_synced: bool,
338    /// Current device clock unix timestamp, set by the cloud sync
339    #[prost(uint64, tag = "10")]
340    pub cloud_clock: u64,
341    /// Whether the Ark is paired with a companion app (user data initialized)
342    #[prost(bool, tag = "11")]
343    pub paired: bool,
344    /// Whether the user data storage is open (false if unpaired)
345    #[prost(bool, tag = "12")]
346    pub unlocked: bool,
347}
348/// CloudSyncStartRequest requests the device to start a synchronization procedure
349/// against the cloud servers to establish the current time as well as the currently
350/// active cloud identity.
351#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
352pub struct CloudSyncStartRequest {
353    /// Post-quantum CWT attestation for the server signing (xDSA) key
354    #[prost(bytes = "vec", tag = "1")]
355    pub signer: ::prost::alloc::vec::Vec<u8>,
356    /// Post-quantum CWT attestation for the server encryption (xHPKE) key
357    #[prost(bytes = "vec", tag = "2")]
358    pub crypto: ::prost::alloc::vec::Vec<u8>,
359}
360/// CloudSyncStartResponse is an initiation of a cloud sync from the device, authed
361/// to the requested cloud identity.
362#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
363pub struct CloudSyncStartResponse {
364    /// Random nonce to avoid malicious host machines setting bad times
365    #[prost(bytes = "vec", tag = "1")]
366    pub challenge: ::prost::alloc::vec::Vec<u8>,
367}
368/// CloudSyncFinishRequest is the completion of a previously initiated cloud sync
369/// procedure, this time being signed by a single identity currently used by the
370/// cloud.
371#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
372pub struct CloudSyncFinishRequest {
373    /// Unix timestamp from the server in milliseconds
374    #[prost(uint64, tag = "1")]
375    pub unixmilli: u64,
376    /// SignAt[Cloud]["cloudsync-v1"][unixmilli/1000](CBOR(challenge))
377    #[prost(bytes = "vec", tag = "2")]
378    pub signature: ::prost::alloc::vec::Vec<u8>,
379}
380/// CloudSyncFinishResponse is the acknowledgement whether the device accepted the
381/// cloud sync from the server or rejected for some reason.
382#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
383pub struct CloudSyncFinishResponse {
384    /// Timestamp that was accepted and set
385    #[prost(uint64, tag = "1")]
386    pub accepted: u64,
387}
388/// GenuinityProofRequest requests the device to generate a cryptographic proof of
389/// its own authenticity.
390#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
391pub struct GenuinityProofRequest {}
392/// GenuinityProofResponse is the device genuinity proof, an encrypted signature
393/// of the device.
394#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
395pub struct GenuinityProofResponse {
396    /// Seal[Ark->Cloud]["genuinity-v1"][null](null)
397    #[prost(bytes = "vec", tag = "1")]
398    pub proof: ::prost::alloc::vec::Vec<u8>,
399}
400/// FirmwareUpdatePrepRequest prepares a firmware update procedure. If any previous
401/// update procedure was in progress, it is aborted.
402#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
403pub struct FirmwareUpdatePrepRequest {
404    /// Version string to update to
405    #[prost(string, tag = "1")]
406    pub version: ::prost::alloc::string::String,
407    /// SHA256 hash of the (encrypted) firmware archive
408    #[prost(bytes = "vec", tag = "2")]
409    pub sha256: ::prost::alloc::vec::Vec<u8>,
410    /// Number of bytes (progress purposes, ignored otherwise)
411    #[prost(uint64, tag = "3")]
412    pub bytes: u64,
413}
414/// FirmwareUpdatePrepResponse confirms that a new firmware update procedure
415/// started. A rejected request gets an error instead.
416///
417/// The Ark generates a fresh ephemeral encryption key to receive the firmware
418/// access key. Its public half is sealed to the cloud, bound to the requested
419/// version and hash.
420#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
421pub struct FirmwareUpdatePrepResponse {
422    /// Seal[Ark->Cloud]["firmware-v1"][\[version, sha256\]](temp-key)
423    #[prost(bytes = "vec", tag = "1")]
424    pub auth: ::prost::alloc::vec::Vec<u8>,
425}
426/// FirmwareUpdateInitRequest initiates a previously prepared firmware update
427/// procedure by providing the authenticated and encrypted firmware key.
428///
429/// Note, if the initiation is rejected, the entire update process is torn down.
430#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
431pub struct FirmwareUpdateInitRequest {
432    /// Seal[Cloud->temp-key]["firmware-v1"][\[version, sha256\]](sym-key)
433    #[prost(bytes = "vec", tag = "1")]
434    pub access: ::prost::alloc::vec::Vec<u8>,
435}
436/// FirmwareUpdateInitResponse acknowledges the initiated update procedure. A
437/// rejected request gets an error instead.
438///
439/// Note, if the init is rejected, the entire update process is torn down.
440#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
441pub struct FirmwareUpdateInitResponse {}
442/// FirmwareUpdateUploadRequest requests appending a new chunk of data to the
443/// currently pending firmware upload process.
444#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
445pub struct FirmwareUpdateUploadRequest {
446    /// Chunk of firmware blob to append (reasonably capped)
447    #[prost(bytes = "vec", tag = "1")]
448    pub chunk: ::prost::alloc::vec::Vec<u8>,
449}
450/// FirmwareUpdateUploadResponse is the response whether the requested chunk was
451/// accepted or rejected.
452///
453/// Note, if the upload is rejected, the entire update process is torn down.
454#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
455pub struct FirmwareUpdateUploadResponse {}
456/// FirmwareUpdateVerifyRequest requests decrypting the uploaded firmware and
457/// verifying its contents, preparing for the last step of actually installing
458/// the firmware update.
459#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
460pub struct FirmwareUpdateVerifyRequest {}
461/// FirmwareUpdateVerifyResponse is the response whether the firmware just uploaded
462/// passed all verifications and is ready for application.
463///
464/// Note, if the verification is rejected, the entire update process is torn down.
465#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
466pub struct FirmwareUpdateVerifyResponse {}
467/// FirmwareUpdateInstallRequest requests the currently pending (but already
468/// verified) firmware to be applied to disk. This message will cause the device
469/// to reboot if applied successfully.
470#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
471pub struct FirmwareUpdateInstallRequest {}
472/// FirmwareUpdateInstallResponse is the response whether the firmware was applied
473/// successfully or not.
474#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
475pub struct FirmwareUpdateInstallResponse {}
476/// PairingAuthRequest requests the initiation of a pairing.
477#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
478pub struct PairingAuthRequest {}
479/// PairingAuthResponse responds whether the device is in a state compatible with
480/// pairing (i.e. reset) and if so, it signs an authorization for the server to open
481/// a new rendezvous point; containing the xHPKE public key to use for encrypting
482/// messages to this Ark after pairing.
483#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
484pub struct PairingAuthResponse {
485    /// Seal[Ark->Cloud]["pairing-v1"][null](pair-key)
486    #[prost(bytes = "vec", tag = "1")]
487    pub auth: ::prost::alloc::vec::Vec<u8>,
488    /// Fingerprint of the pair-key to transmit to the app out-of-protocol
489    #[prost(bytes = "vec", tag = "2")]
490    pub fprint: ::prost::alloc::vec::Vec<u8>,
491}
492/// PairingSetAppIdentityRequest injects the companion app's identity, relayed
493/// by the cloud.
494#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
495pub struct PairingSetAppIdentityRequest {
496    /// Seal[Cloud->Ark]["pairing-v1:identity"][\[ark_signer_id, ark_crypto_id\]](\[app_signer, app_crypto\])
497    #[prost(bytes = "vec", tag = "1")]
498    pub identity: ::prost::alloc::vec::Vec<u8>,
499}
500/// PairingSetAppIdentityResponse confirms whether the remote identity was
501/// accepted by the Ark or not.
502#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
503pub struct PairingSetAppIdentityResponse {}
504/// PairingSetAppStorageRequest injects the app's storage key material into the
505/// pairing flow.
506#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
507pub struct PairingSetAppStorageRequest {
508    /// Seal[App->Ark]["pairing-v1:storage"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](\[app_keymat\])
509    #[prost(bytes = "vec", tag = "1")]
510    pub app_key: ::prost::alloc::vec::Vec<u8>,
511}
512/// PairingSetAppStorageResponse confirms whether the remote storage material
513/// was accepted, and if so, bundles the ark device infos and ark key material.
514#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
515pub struct PairingSetAppStorageResponse {
516    /// Seal[Ark->App]["pairing-v1:storage"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id, app_keymat\]](\[hw_ver, hw_rev, fw_ver, fw_pub, ark_keymat\])
517    #[prost(bytes = "vec", tag = "1")]
518    pub ark_keys: ::prost::alloc::vec::Vec<u8>,
519}
520/// PairingAckArkStorageRequest confirms from the app that the Ark's key material
521/// was received correctly.
522#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
523pub struct PairingAckArkStorageRequest {
524    /// Seal[App->Ark]["pairing-v1:storage"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id, ark_keymat\]](null)
525    #[prost(bytes = "vec", tag = "1")]
526    pub app_ack: ::prost::alloc::vec::Vec<u8>,
527}
528/// PairingAckArkStorageResponse confirms that the key ack was accepted.
529#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
530pub struct PairingAckArkStorageResponse {}
531/// PairingAcceptanceRequest is a blocking poller to wait until the user accepts
532/// a pairing request or it times out.
533#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
534pub struct PairingAcceptanceRequest {}
535/// PairingAcceptanceResponse returns whether the user accepted the pairing or
536/// if it timed out. At this point, the device still needs to format itself.
537#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
538pub struct PairingAcceptanceResponse {
539    /// Seal[Ark->Cloud]["pairing-v1:accept"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](null)
540    #[prost(bytes = "vec", tag = "1")]
541    pub confirm: ::prost::alloc::vec::Vec<u8>,
542}
543/// PairingCompletionRequest is a blocking poller to wait until the device finishes
544/// any pairing maintenance operation (e.g. encrypting itself).
545#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
546pub struct PairingCompletionRequest {}
547/// PairingCompletionResponse returns whether the device finished preparing for
548/// live operation.
549#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
550pub struct PairingCompletionResponse {
551    /// Seal[Ark->Cloud]["pairing-v1:complete"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](null)
552    #[prost(bytes = "vec", tag = "1")]
553    pub confirm: ::prost::alloc::vec::Vec<u8>,
554}
555/// RelayJoinRequest requests authorization to join the communication relay with
556/// the companion app.
557#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
558pub struct RelayJoinRequest {}
559/// RelayJoinResponse responds whether the device is in a state compatible with
560/// relaying (i.e. paired) and if so, it signs an authorization for the server
561/// to join the rendezvous point.
562#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
563pub struct RelayJoinResponse {
564    /// Seal[Ark->Cloud]["relaying-v2:join"][cloud_crypto_id](null)
565    #[prost(bytes = "vec", tag = "1")]
566    pub auth: ::prost::alloc::vec::Vec<u8>,
567}
568/// RelayInboundRequest forwards one frame from the host's relay socket to the Ark.
569///
570/// The relay connects the Ark with its companion app through the host and the
571/// cloud. Its frames are opaque to the host, which forwards them unchanged in
572/// both directions and never interprets them. Each frame is sealed to its
573/// recipient by the other endpoint, or by the cloud itself, and its
574/// authenticated data names the recipient's encryption key.
575///
576/// The host sends one request for each message its relay socket delivers, in
577/// arrival order.
578#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
579pub struct RelayInboundRequest {
580    /// Seal[App|Cloud->Ark]["relaying-v2:frame"][ark_crypto_id](...)
581    #[prost(bytes = "vec", tag = "1")]
582    pub frame: ::prost::alloc::vec::Vec<u8>,
583}
584/// RelayInboundResponse confirms the Ark opened the frame, which decrypted and
585/// verified. The Ark answers before acting on the frame's content, and refuses
586/// a frame it cannot open with an error whose message names the cause.
587#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
588pub struct RelayInboundResponse {}
589/// RelayOutboundRequest asks the host to write one frame to its relay socket.
590///
591/// A host without a relay socket attaches one first through relay_join. If it
592/// cannot, it answers with the reserved UNAVAILABLE error.
593#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
594pub struct RelayOutboundRequest {
595    /// Seal[Ark->App]["relaying-v2:frame"][app_crypto_id](...)
596    #[prost(bytes = "vec", tag = "1")]
597    pub frame: ::prost::alloc::vec::Vec<u8>,
598}
599/// RelayOutboundResponse confirms that the relay socket accepted the frame, which
600/// does not mean the frame reached the app.
601#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
602pub struct RelayOutboundResponse {}
603/// UnlockRequest asks the Ark to open its user data storage.
604///
605/// The Ark answers once the owner approves or declines on their phone, or the
606/// approval window runs out.
607#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
608pub struct UnlockRequest {}
609/// UnlockResponse acknowledges the completed unlock. Any other outcome gets an
610/// error instead.
611#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
612pub struct UnlockResponse {}
613/// ExecutionUploadStartRequest begins a chunked upload of a WASM binary to
614/// execute. The declared size is used to pre-allocate the receive buffer and
615/// to reject oversized uploads early; the actual bytes are sent via subsequent
616/// ExecutionUploadChunkRequest messages.
617#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
618pub struct ExecutionUploadStartRequest {
619    /// Total binary size in bytes
620    #[prost(uint64, tag = "1")]
621    pub bytes: u64,
622}
623/// ExecutionUploadStartResponse contains the task id to use for subsequent
624/// chunk, schedule and cancel messages.
625#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
626pub struct ExecutionUploadStartResponse {
627    /// Task id to stream chunks into
628    #[prost(uint64, tag = "1")]
629    pub taskid: u64,
630}
631/// ExecutionUploadChunkRequest appends a chunk of data to a pending upload.
632/// Chunks must be appended in order and must not overrun the declared size.
633#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
634pub struct ExecutionUploadChunkRequest {
635    /// Task id to append to
636    #[prost(uint64, tag = "1")]
637    pub taskid: u64,
638    /// Data chunk to append (reasonably capped)
639    #[prost(bytes = "vec", tag = "2")]
640    pub chunk: ::prost::alloc::vec::Vec<u8>,
641}
642/// ExecutionUploadChunkResponse is an empty ack of the chunk upload request.
643#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
644pub struct ExecutionUploadChunkResponse {}
645/// ExecutionScheduleRequest finalizes an upload and requests the device to
646/// execute the uploaded 3rd party app. The upload must have been completed
647/// (i.e. the sum of chunk sizes matches the declared size).
648///
649/// The Ark answers once the owner approves or declines on their phone, or the
650/// approval window runs out.
651#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
652pub struct ExecutionScheduleRequest {
653    /// Task id returned by ExecutionUploadStartResponse
654    #[prost(uint64, tag = "1")]
655    pub taskid: u64,
656}
657/// ExecutionScheduleResponse acks that the execution was authorized and the
658/// task is now running. The host already holds the task id from the preceding
659/// ExecutionUploadStartResponse.
660#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
661pub struct ExecutionScheduleResponse {}
662/// ExecutionCancelRequest cancels a previously started 3rd party app run or
663/// an in-progress upload.
664#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
665pub struct ExecutionCancelRequest {
666    /// Task id to cancel
667    #[prost(uint64, tag = "1")]
668    pub taskid: u64,
669}
670/// ExecutionCancelResponse acknowledges the canceled app run or upload.
671#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
672pub struct ExecutionCancelResponse {}
673/// ExecutionStatusRequest checks the execution status of a previously started
674/// 3rd party app run.
675#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
676pub struct ExecutionStatusRequest {
677    /// Pending execution ID to check for updates
678    #[prost(uint64, tag = "1")]
679    pub taskid: u64,
680}
681/// ExecutionResultResponse contains the data gathered during an app's execution.
682#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
683pub struct ExecutionResultResponse {
684    /// Name of the executed app
685    #[prost(string, tag = "2")]
686    pub app_name: ::prost::alloc::string::String,
687    /// Version of the executed app
688    #[prost(string, tag = "3")]
689    pub app_version: ::prost::alloc::string::String,
690    /// Whether the task finished successfully
691    #[prost(bool, tag = "4")]
692    pub success: bool,
693    /// Raw standard output of the app
694    #[prost(bytes = "vec", tag = "5")]
695    pub stdout: ::prost::alloc::vec::Vec<u8>,
696    /// Raw standard error the app (only in develop mode)
697    #[prost(bytes = "vec", tag = "6")]
698    pub stderr: ::prost::alloc::vec::Vec<u8>,
699}
700/// ExecutionStatusResponse contains the status of a started 3rd party app
701/// execution.
702#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
703pub struct ExecutionStatusResponse {
704    /// Whether the app is still running
705    #[prost(bool, tag = "1")]
706    pub pending: bool,
707    /// The result of the execution
708    #[prost(message, optional, tag = "2")]
709    pub result: ::core::option::Option<ExecutionResultResponse>,
710}
711/// SlotDownload describes the public download the device advertises for a
712/// reference slot, so a host can fetch it and stream it back in.
713#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
714pub struct SlotDownload {
715    /// Public download URL
716    #[prost(string, tag = "1")]
717    pub url: ::prost::alloc::string::String,
718    /// Download size in bytes
719    #[prost(uint64, tag = "2")]
720    pub bytes: u64,
721    /// Download SHA256 checksum
722    #[prost(string, tag = "3")]
723    pub sha256: ::prost::alloc::string::String,
724}
725/// SlotStatus describes the current state of a single slot on the device. The
726/// data fields are generic so a host renders a kind it has never seen.
727#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
728pub struct SlotStatus {
729    /// Slot type
730    #[prost(enumeration = "SlotKind", tag = "1")]
731    pub kind: i32,
732    /// Human-readable slot name
733    #[prost(string, tag = "2")]
734    pub name: ::prost::alloc::string::String,
735    /// Owner-facing description of the data this slot holds
736    #[prost(string, tag = "3")]
737    pub desc: ::prost::alloc::string::String,
738    /// The file that fills this slot, its required shape and what is refused
739    #[prost(string, tag = "4")]
740    pub format: ::prost::alloc::string::String,
741    /// Nature of the data (personal, reference)
742    #[prost(enumeration = "SlotOrigin", tag = "5")]
743    pub origin: i32,
744    /// Whether the slot is empty, filled or damaged
745    #[prost(enumeration = "SlotState", tag = "6")]
746    pub state: i32,
747    /// Why the slot is damaged, empty otherwise
748    #[prost(string, tag = "7")]
749    pub damage: ::prost::alloc::string::String,
750    /// Slots that must be filled before this one is actionable
751    #[prost(enumeration = "SlotKind", repeated, tag = "8")]
752    pub deps: ::prost::alloc::vec::Vec<i32>,
753    /// Bytes on disk for this slot (0 if empty)
754    #[prost(uint64, tag = "9")]
755    pub bytes: u64,
756    /// Reference assembly the data is keyed to (e.g. "GRCh38.p14")
757    #[prost(string, tag = "10")]
758    pub build: ::prost::alloc::string::String,
759    /// The dataset's own release, if it has one (e.g. dbSNP "157")
760    #[prost(string, tag = "11")]
761    pub version: ::prost::alloc::string::String,
762    /// Advertised public download, absent if none
763    #[prost(message, optional, tag = "12")]
764    pub download: ::core::option::Option<SlotDownload>,
765}
766/// SlotListRequest requests the state of all slots on the device.
767#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
768pub struct SlotListRequest {}
769/// SlotListResponse contains the current state of every slot.
770#[derive(Clone, PartialEq, ::prost::Message)]
771pub struct SlotListResponse {
772    /// State of every slot, one entry per slot kind
773    #[prost(message, repeated, tag = "1")]
774    pub slots: ::prost::alloc::vec::Vec<SlotStatus>,
775}
776/// SlotRepairRequest resets a slot to empty regardless of its current state.
777/// Unlike SlotDelete (which requires the slot to be filled), repair is a stateless
778/// force cleanup that removes any leftover metadata and/or files on disk. It is
779/// intended for recovering from corruption or half-written state after crashes.
780#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
781pub struct SlotRepairRequest {
782    /// Slot to repair (reset to empty)
783    #[prost(enumeration = "SlotKind", tag = "1")]
784    pub slot: i32,
785}
786/// SlotRepairResponse is an empty ack of the repair request.
787#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
788pub struct SlotRepairResponse {}
789/// SlotDeleteRequest removes the contents of a filled slot. The slot must be
790/// in a healthy, filled state; corrupted or half-written slots must be cleaned
791/// up via SlotRepair instead.
792#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
793pub struct SlotDeleteRequest {
794    /// Slot to delete
795    #[prost(enumeration = "SlotKind", tag = "1")]
796    pub slot: i32,
797}
798/// SlotDeleteResponse is an empty ack of the delete request.
799#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
800pub struct SlotDeleteResponse {}
801/// SlotIdentifyRequest sends an ephemeral file chunk to the Ark and asks it to
802/// identify the file. Its purpose is to filter potentially huge files (e.g. a
803/// 30GB compressed whole genome sequencing) before uploading them, and to
804/// answer what a file is without uploading it at all.
805#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
806pub struct SlotIdentifyRequest {
807    /// File name to guess the contents of
808    #[prost(string, tag = "1")]
809    pub name: ::prost::alloc::string::String,
810    /// File size to guess the contents of
811    #[prost(uint64, tag = "2")]
812    pub size: u64,
813    /// First chunk of the file to guess the contents of
814    #[prost(bytes = "vec", tag = "3")]
815    pub chunk: ::prost::alloc::vec::Vec<u8>,
816    /// Possible slots to interpret as (empty == any)
817    #[prost(enumeration = "SlotKind", repeated, tag = "4")]
818    pub kinds: ::prost::alloc::vec::Vec<i32>,
819}
820/// SlotIdentifyResponse contains the identification based on the chunk shared
821/// in the request.
822#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
823pub struct SlotIdentifyResponse {
824    /// Identified slot type to use during upload
825    #[prost(enumeration = "SlotKind", tag = "1")]
826    pub kind: i32,
827    /// Identification confidence level
828    #[prost(enumeration = "SlotConfidence", tag = "2")]
829    pub conf: i32,
830    /// Short summary of the identified data
831    #[prost(string, tag = "3")]
832    pub summary: ::prost::alloc::string::String,
833    /// Detailed description of the identified data
834    #[prost(string, tag = "4")]
835    pub details: ::prost::alloc::string::String,
836    /// Reason why the file is rejected, empty otherwise
837    #[prost(string, tag = "5")]
838    pub rejection: ::prost::alloc::string::String,
839}
840/// SlotUploadStartRequest requests uploading a file into a slot of the given
841/// kind (e.g. a whole genome variant call file).
842#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
843pub struct SlotUploadStartRequest {
844    /// Slot type requesting to upload
845    #[prost(enumeration = "SlotKind", tag = "1")]
846    pub kind: i32,
847    /// File name to guess the contents of
848    #[prost(string, tag = "2")]
849    pub name: ::prost::alloc::string::String,
850    /// File size to guess the contents of
851    #[prost(uint64, tag = "3")]
852    pub size: u64,
853    /// First chunk of the file to guess the contents of
854    #[prost(bytes = "vec", tag = "4")]
855    pub chunk: ::prost::alloc::vec::Vec<u8>,
856}
857/// SlotUploadStartResponse contains a unique session id for an approved upload.
858#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
859pub struct SlotUploadStartResponse {
860    /// Session id for concurrent uploads (not recommended)
861    #[prost(uint64, tag = "1")]
862    pub session: u64,
863}
864/// SlotUploadChunkRequest contains a new chunk of data to append to a pending
865/// upload session.
866#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
867pub struct SlotUploadChunkRequest {
868    /// Session id into which to append a new chunk
869    #[prost(uint64, tag = "1")]
870    pub session: u64,
871    /// Data chunk to append (reasonably capped)
872    #[prost(bytes = "vec", tag = "2")]
873    pub chunk: ::prost::alloc::vec::Vec<u8>,
874}
875/// SlotUploadChunkResponse is an empty ack of the chunk upload request.
876#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
877pub struct SlotUploadChunkResponse {}
878/// SlotUploadCancelRequest contains an upload session id to abort.
879#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
880pub struct SlotUploadCancelRequest {
881    /// Session id to cancel
882    #[prost(uint64, tag = "1")]
883    pub session: u64,
884}
885/// SlotUploadCancelResponse is an empty ack of the cancellation request.
886#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
887pub struct SlotUploadCancelResponse {}
888/// SlotPhase names one step of a slot's processing pipeline.
889#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
890pub struct SlotPhase {
891    /// Short label for the phase
892    #[prost(string, tag = "1")]
893    pub name: ::prost::alloc::string::String,
894    /// Description of what the phase does
895    #[prost(string, tag = "2")]
896    pub desc: ::prost::alloc::string::String,
897}
898/// SlotUploadProcessRequest marks an upload session ready for processing and
899/// requests a progress report to be sent back. May be called multiple times.
900#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
901pub struct SlotUploadProcessRequest {
902    /// Session id to mark as completed
903    #[prost(uint64, tag = "1")]
904    pub session: u64,
905}
906/// SlotUploadProcessResponse acks the completion of a slot upload and also
907/// contains the current processing progress.
908#[derive(Clone, PartialEq, ::prost::Message)]
909pub struct SlotUploadProcessResponse {
910    /// Unix timestamp when data processing started
911    #[prost(uint64, tag = "1")]
912    pub proc_start: u64,
913    /// Every phase of the pipeline, in order
914    #[prost(message, repeated, tag = "2")]
915    pub phases: ::prost::alloc::vec::Vec<SlotPhase>,
916    /// Current phase (1-indexed)
917    #[prost(uint64, tag = "3")]
918    pub phase_in: u64,
919    /// Unix timestamp when the current phase started
920    #[prost(uint64, tag = "4")]
921    pub phase_start: u64,
922    /// Approximate progress for this phase \[0-10000\]
923    #[prost(uint64, tag = "5")]
924    pub phase_progress: u64,
925    /// Failure reason if processing failed, empty otherwise
926    #[prost(string, tag = "6")]
927    pub failure: ::prost::alloc::string::String,
928}
929/// DatasetPathsRequest requests the map of every path an app can read, the
930/// dataset view the device derives from its slots, lenses included.
931#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
932pub struct DatasetPathsRequest {}
933/// DatasetPathsResponse maps every path an app can read, available or not, in
934/// tree order. It describes the tree only and never carries a value from the
935/// owner's data.
936#[derive(Clone, PartialEq, ::prost::Message)]
937pub struct DatasetPathsResponse {
938    /// Every path pattern, in tree order
939    #[prost(message, repeated, tag = "1")]
940    pub paths: ::prost::alloc::vec::Vec<DatasetPath>,
941}
942/// DatasetPath describes one path pattern under the data root. A segment in angle
943/// brackets is a placeholder, described by the directory entry it names. The path
944/// is the entry's stable key.
945#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
946pub struct DatasetPath {
947    /// Path as a manifest names it
948    #[prost(string, tag = "1")]
949    pub path: ::prost::alloc::string::String,
950    /// Directory or file
951    #[prost(bool, tag = "2")]
952    pub directory: bool,
953    /// Whether a manifest may name it
954    #[prost(bool, tag = "3")]
955    pub grantable: bool,
956    /// Whether the data this path needs is on the Ark now
957    #[prost(bool, tag = "4")]
958    pub available: bool,
959    /// What it holds, when it is absent and when it fails
960    #[prost(string, tag = "5")]
961    pub desc: ::prost::alloc::string::String,
962    /// Exact file content, or what a directory lists
963    #[prost(string, tag = "6")]
964    pub format: ::prost::alloc::string::String,
965    /// Complete example values, most typical first
966    #[prost(string, repeated, tag = "7")]
967    pub examples: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
968}
969/// ReservedErrors names the assigned protocol-wide errors in the reserved range
970/// 0x00 to 0xff (inclusive). No code in this range may be assigned a request
971/// specific meaning. Assigned codes must not be repurposed.
972#[non_exhaustive]
973#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
974#[repr(i32)]
975pub enum ReservedErrors {
976    /// A failure without a standardized reason. Zero does not indicate success;
977    /// the presence of an Error in the response indicates failure.
978    Unspecified = 0,
979    /// The request's responder was released without providing an application reply.
980    Unanswered = 1,
981    /// The peer does not know this request. Emitted by the protocol layer itself
982    /// when a request's content is not in its schema.
983    Unknown = 2,
984    /// The peer knows this request but never serves it in this build or role,
985    /// firmware updates on an emulator or develop envelopes on production.
986    Unsupported = 3,
987    /// The peer serves this request but not in its current state, before cloud
988    /// sync or pairing. It may once the state changes.
989    Unavailable = 4,
990    /// The peer serves this request but the approval it asked for on the phone
991    /// did not authorize it. The owner declined, or the phone's answer broke the
992    /// approval's rules and counts as a decline.
993    Unauthorized = 5,
994    /// The peer serves this request but the approval it asked for did not arrive
995    /// before its window ran out, on the phone or at the button.
996    Unconfirmed = 6,
997    /// The peer serves this request but the approval it asked for could not be
998    /// sent to the phone, since the relay failed on the way.
999    Undelivered = 7,
1000}
1001impl ReservedErrors {
1002    /// String value of the enum field names used in the ProtoBuf definition.
1003    ///
1004    /// The values are not transformed in any way and thus are considered stable
1005    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1006    pub fn as_str_name(&self) -> &'static str {
1007        match self {
1008            Self::Unspecified => "RESERVED_ERRORS_UNSPECIFIED",
1009            Self::Unanswered => "RESERVED_ERRORS_UNANSWERED",
1010            Self::Unknown => "RESERVED_ERRORS_UNKNOWN",
1011            Self::Unsupported => "RESERVED_ERRORS_UNSUPPORTED",
1012            Self::Unavailable => "RESERVED_ERRORS_UNAVAILABLE",
1013            Self::Unauthorized => "RESERVED_ERRORS_UNAUTHORIZED",
1014            Self::Unconfirmed => "RESERVED_ERRORS_UNCONFIRMED",
1015            Self::Undelivered => "RESERVED_ERRORS_UNDELIVERED",
1016        }
1017    }
1018    /// Creates an enum from field names used in the ProtoBuf definition.
1019    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1020        match value {
1021            "RESERVED_ERRORS_UNSPECIFIED" => Some(Self::Unspecified),
1022            "RESERVED_ERRORS_UNANSWERED" => Some(Self::Unanswered),
1023            "RESERVED_ERRORS_UNKNOWN" => Some(Self::Unknown),
1024            "RESERVED_ERRORS_UNSUPPORTED" => Some(Self::Unsupported),
1025            "RESERVED_ERRORS_UNAVAILABLE" => Some(Self::Unavailable),
1026            "RESERVED_ERRORS_UNAUTHORIZED" => Some(Self::Unauthorized),
1027            "RESERVED_ERRORS_UNCONFIRMED" => Some(Self::Unconfirmed),
1028            "RESERVED_ERRORS_UNDELIVERED" => Some(Self::Undelivered),
1029            _ => None,
1030        }
1031    }
1032}
1033/// SlotKind identifies a slot on the device. Each value corresponds to a unique
1034/// data type that the device can store and manage.
1035#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1036#[repr(i32)]
1037pub enum SlotKind {
1038    /// Never sent, an unset kind
1039    SlotUnspecified = 0,
1040    /// Human reference genome assembly
1041    SlotReferenceGenome = 1,
1042    /// Gene-to-coordinate mapping database
1043    SlotGeneAnnotations = 2,
1044    /// User's SNP/indel variant calls
1045    SlotSnpIndelCalls = 3,
1046    /// Variant catalog (rsID-to-position), from dbSNP
1047    SlotVariantCatalog = 4,
1048}
1049impl SlotKind {
1050    /// String value of the enum field names used in the ProtoBuf definition.
1051    ///
1052    /// The values are not transformed in any way and thus are considered stable
1053    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1054    pub fn as_str_name(&self) -> &'static str {
1055        match self {
1056            Self::SlotUnspecified => "SLOT_UNSPECIFIED",
1057            Self::SlotReferenceGenome => "SLOT_REFERENCE_GENOME",
1058            Self::SlotGeneAnnotations => "SLOT_GENE_ANNOTATIONS",
1059            Self::SlotSnpIndelCalls => "SLOT_SNP_INDEL_CALLS",
1060            Self::SlotVariantCatalog => "SLOT_VARIANT_CATALOG",
1061        }
1062    }
1063    /// Creates an enum from field names used in the ProtoBuf definition.
1064    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1065        match value {
1066            "SLOT_UNSPECIFIED" => Some(Self::SlotUnspecified),
1067            "SLOT_REFERENCE_GENOME" => Some(Self::SlotReferenceGenome),
1068            "SLOT_GENE_ANNOTATIONS" => Some(Self::SlotGeneAnnotations),
1069            "SLOT_SNP_INDEL_CALLS" => Some(Self::SlotSnpIndelCalls),
1070            "SLOT_VARIANT_CATALOG" => Some(Self::SlotVariantCatalog),
1071            _ => None,
1072        }
1073    }
1074}
1075/// SlotOrigin describes the nature of the data in a slot, determining what
1076/// actions are available to the user for filling it.
1077#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1078#[repr(i32)]
1079pub enum SlotOrigin {
1080    /// Never sent, an unset origin
1081    OriginUnspecified = 0,
1082    /// Unique to the user, uploaded by them
1083    OriginPersonal = 1,
1084    /// Standard reference data, downloaded from public sources
1085    OriginReference = 2,
1086}
1087impl SlotOrigin {
1088    /// String value of the enum field names used in the ProtoBuf definition.
1089    ///
1090    /// The values are not transformed in any way and thus are considered stable
1091    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1092    pub fn as_str_name(&self) -> &'static str {
1093        match self {
1094            Self::OriginUnspecified => "ORIGIN_UNSPECIFIED",
1095            Self::OriginPersonal => "ORIGIN_PERSONAL",
1096            Self::OriginReference => "ORIGIN_REFERENCE",
1097        }
1098    }
1099    /// Creates an enum from field names used in the ProtoBuf definition.
1100    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1101        match value {
1102            "ORIGIN_UNSPECIFIED" => Some(Self::OriginUnspecified),
1103            "ORIGIN_PERSONAL" => Some(Self::OriginPersonal),
1104            "ORIGIN_REFERENCE" => Some(Self::OriginReference),
1105            _ => None,
1106        }
1107    }
1108}
1109/// SlotState describes whether a slot holds data and whether that data is sound.
1110#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1111#[repr(i32)]
1112pub enum SlotState {
1113    /// Never sent, an unset state
1114    StateUnspecified = 0,
1115    /// Nothing stored
1116    StateEmpty = 1,
1117    /// Data present and healthy
1118    StateFilled = 2,
1119    /// Files exist but the metadata is missing, corrupt or outdated
1120    StateDamaged = 3,
1121}
1122impl SlotState {
1123    /// String value of the enum field names used in the ProtoBuf definition.
1124    ///
1125    /// The values are not transformed in any way and thus are considered stable
1126    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1127    pub fn as_str_name(&self) -> &'static str {
1128        match self {
1129            Self::StateUnspecified => "STATE_UNSPECIFIED",
1130            Self::StateEmpty => "STATE_EMPTY",
1131            Self::StateFilled => "STATE_FILLED",
1132            Self::StateDamaged => "STATE_DAMAGED",
1133        }
1134    }
1135    /// Creates an enum from field names used in the ProtoBuf definition.
1136    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1137        match value {
1138            "STATE_UNSPECIFIED" => Some(Self::StateUnspecified),
1139            "STATE_EMPTY" => Some(Self::StateEmpty),
1140            "STATE_FILLED" => Some(Self::StateFilled),
1141            "STATE_DAMAGED" => Some(Self::StateDamaged),
1142            _ => None,
1143        }
1144    }
1145}
1146/// SlotConfidence indicates how confident the device is in its identification
1147/// of a file, based on content, filename and size.
1148#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1149#[repr(i32)]
1150pub enum SlotConfidence {
1151    /// Never sent, an unset confidence
1152    ConfidenceUnspecified = 0,
1153    /// Filename/extension only, no content confirmation
1154    ConfidenceLow = 1,
1155    /// Format detected but slot type inferred from size/filename
1156    ConfidenceMid = 2,
1157    /// Magic bytes match and format-specific content confirmed
1158    ConfidenceHigh = 3,
1159}
1160impl SlotConfidence {
1161    /// String value of the enum field names used in the ProtoBuf definition.
1162    ///
1163    /// The values are not transformed in any way and thus are considered stable
1164    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1165    pub fn as_str_name(&self) -> &'static str {
1166        match self {
1167            Self::ConfidenceUnspecified => "CONFIDENCE_UNSPECIFIED",
1168            Self::ConfidenceLow => "CONFIDENCE_LOW",
1169            Self::ConfidenceMid => "CONFIDENCE_MID",
1170            Self::ConfidenceHigh => "CONFIDENCE_HIGH",
1171        }
1172    }
1173    /// Creates an enum from field names used in the ProtoBuf definition.
1174    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1175        match value {
1176            "CONFIDENCE_UNSPECIFIED" => Some(Self::ConfidenceUnspecified),
1177            "CONFIDENCE_LOW" => Some(Self::ConfidenceLow),
1178            "CONFIDENCE_MID" => Some(Self::ConfidenceMid),
1179            "CONFIDENCE_HIGH" => Some(Self::ConfidenceHigh),
1180            _ => None,
1181        }
1182    }
1183}
darkbio_wire/protocol/generated/darkbio.wire.rs

darkbio_wire/protocol/generated/
darkbio.wire.rs
