darkbio-wire 0.16.0

// This file is @generated by prost-build.
/// HostToArk represents a message sent from the host to the Ark via the USB
/// connection. It embeds all possible message types to keep the protocol simple.
///
/// Every message carries an id and is either a request, its id chosen by the
/// host, or the host's response to a request of the Ark, echoing the Ark's id.
/// To avoid id collisions, hosts allocate odd ids and Arks even ones, so the
/// parity of the id alone distinguishes a response from a request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct HostToArk {
    /// Enveloping fields, reserved range 0x001-0x0ff
    ///
    /// Request identifier, the host's own or responded to
    #[prost(uint64, tag = "1")]
    pub id: u64,
    /// Error encountered while serving the Ark's request (if any)
    #[prost(message, optional, tag = "2")]
    pub err: ::core::option::Option<Error>,
    /// Body of the message, a request of the host or its response to a request of
    /// the Ark. The tags are grouped by area, each area with its own range.
    #[prost(
        oneof = "host_to_ark::Content",
        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, 1287, 1288, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1793, 4096"
    )]
    pub content: ::core::option::Option<host_to_ark::Content>,
}
/// Nested message and enum types in `HostToArk`.
pub mod host_to_ark {
    /// Body of the message, a request of the host or its response to a request of
    /// the Ark. The tags are grouped by area, each area with its own range.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Content {
        /// Installs the signed device attestation at manufacturing
        #[prost(message, tag = "256")]
        Onboard(super::OnboardingRequest),
        /// Fetches the hardware and firmware versions
        #[prost(message, tag = "257")]
        DeviceInfo(super::DeviceInfoRequest),
        /// Starts a cloud sync with the attested cloud keys
        #[prost(message, tag = "258")]
        CloudSyncStart(super::CloudSyncStartRequest),
        /// Finishes a cloud sync with the signed server time
        #[prost(message, tag = "259")]
        CloudSyncFinish(super::CloudSyncFinishRequest),
        /// Requests a proof of the device's genuinity
        #[prost(message, tag = "260")]
        GenuinityProof(super::GenuinityProofRequest),
        /// Prepares an update, aborting any in progress
        #[prost(message, tag = "513")]
        FirmwareUpdatePrep(super::FirmwareUpdatePrepRequest),
        /// Initiates a prepared update with the sealed firmware key
        #[prost(message, tag = "514")]
        FirmwareUpdateInit(super::FirmwareUpdateInitRequest),
        /// Appends a chunk of the firmware archive
        #[prost(message, tag = "515")]
        FirmwareUpdateUpload(super::FirmwareUpdateUploadRequest),
        /// Decrypts and verifies the uploaded firmware
        #[prost(message, tag = "516")]
        FirmwareUpdateVerify(super::FirmwareUpdateVerifyRequest),
        /// Installs the verified firmware and reboots
        #[prost(message, tag = "517")]
        FirmwareUpdateInstall(super::FirmwareUpdateInstallRequest),
        /// Asks the Ark to authorize a pairing rendezvous
        #[prost(message, tag = "769")]
        PairingAuth(super::PairingAuthRequest),
        /// Injects the companion app's identity, relayed by the cloud
        #[prost(message, tag = "770")]
        PairingSetAppId(super::PairingSetAppIdentityRequest),
        /// Injects the companion app's storage key material
        #[prost(message, tag = "771")]
        PairingSetAppStorage(super::PairingSetAppStorageRequest),
        /// Confirms the app received the Ark's key material
        #[prost(message, tag = "772")]
        PairingAckArkStorage(super::PairingAckArkStorageRequest),
        /// Waits for the user to accept the pairing
        #[prost(message, tag = "773")]
        PairingAccept(super::PairingAcceptanceRequest),
        /// Waits for the Ark to finish pairing maintenance
        #[prost(message, tag = "774")]
        PairingComplete(super::PairingCompletionRequest),
        /// Asks the Ark to authorize joining the app relay
        #[prost(message, tag = "1025")]
        RelayJoin(super::RelayJoinRequest),
        /// Forwards one frame from the relay socket to the Ark
        #[prost(message, tag = "1026")]
        RelayInbound(super::RelayInboundRequest),
        /// Confirms the relay socket accepted the frame
        #[prost(message, tag = "1027")]
        RelayOutbound(super::RelayOutboundResponse),
        /// Starts the unlock, confirmed through the app
        #[prost(message, tag = "1281")]
        Unlock(super::UnlockRequest),
        /// Begins a chunked upload of an app to execute
        #[prost(message, tag = "1282")]
        ExecUploadStart(super::ExecutionUploadStartRequest),
        /// Appends a chunk to a pending app upload
        #[prost(message, tag = "1283")]
        ExecUploadChunk(super::ExecutionUploadChunkRequest),
        /// Runs an uploaded app, confirmed through the app
        #[prost(message, tag = "1284")]
        ExecSched(super::ExecutionScheduleRequest),
        /// Checks where a scheduled run stands
        #[prost(message, tag = "1285")]
        ExecStatus(super::ExecutionStatusRequest),
        /// Cancels an app run or a pending upload
        #[prost(message, tag = "1286")]
        ExecCancel(super::ExecutionCancelRequest),
        /// Fetches the result of a resolved run
        #[prost(message, tag = "1287")]
        ExecResult(super::ExecutionResultRequest),
        /// Reads the next piece of a released run's output
        #[prost(message, tag = "1288")]
        ExecOutput(super::ExecutionOutputRequest),
        /// Lists the state of every data slot
        #[prost(message, tag = "1537")]
        SlotList(super::SlotListRequest),
        /// Resets a slot to empty whatever its state
        #[prost(message, tag = "1538")]
        SlotRepair(super::SlotRepairRequest),
        /// Removes the contents of a filled slot
        #[prost(message, tag = "1539")]
        SlotDelete(super::SlotDeleteRequest),
        /// Asks the Ark to identify a file from its first chunk
        #[prost(message, tag = "1540")]
        SlotIdentify(super::SlotIdentifyRequest),
        /// Starts uploading a file into a slot
        #[prost(message, tag = "1541")]
        SlotUploadStart(super::SlotUploadStartRequest),
        /// Appends a chunk to a pending slot upload
        #[prost(message, tag = "1542")]
        SlotUploadChunk(super::SlotUploadChunkRequest),
        /// Aborts a pending slot upload
        #[prost(message, tag = "1543")]
        SlotUploadCancel(super::SlotUploadCancelRequest),
        /// Marks an upload complete and polls its processing
        #[prost(message, tag = "1544")]
        SlotUploadProcess(super::SlotUploadProcessRequest),
        /// Maps every path an app can read, from the dataset view
        #[prost(message, tag = "1793")]
        DatasetPaths(super::DatasetPathsRequest),
        /// Unreleased messages served by development firmware only, carried opaquely
        /// so the public protocol is untouched while they are still under development.
        /// Their schema is private and production Arks refuse the envelope.
        #[prost(bytes, tag = "4096")]
        Develop(::prost::alloc::vec::Vec<u8>),
    }
}
/// ArkToHost represents a message sent from the Ark to the host via the USB
/// connection. It embeds all possible message types to keep the protocol simple.
///
/// Every message carries an id and is either a request, its id chosen by the
/// Ark, or the Ark's response to a request of the host, echoing the host's id.
/// To avoid id collisions, hosts allocate odd ids and Arks even ones, so the
/// parity of the id alone distinguishes a response from a request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArkToHost {
    /// Enveloping fields, reserved range 0x001-0x0ff
    ///
    /// Request identifier, responded to or the Ark's own
    #[prost(uint64, tag = "1")]
    pub id: u64,
    /// Error encountered while serving the host's request (if any)
    #[prost(message, optional, tag = "2")]
    pub err: ::core::option::Option<Error>,
    /// Body of the message, a response of the Ark to a request of the host or a
    /// request of its own. The tags are grouped by area, each area with its own range.
    #[prost(
        oneof = "ark_to_host::Content",
        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, 1287, 1288, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1793, 4096"
    )]
    pub content: ::core::option::Option<ark_to_host::Content>,
}
/// Nested message and enum types in `ArkToHost`.
pub mod ark_to_host {
    /// Body of the message, a response of the Ark to a request of the host or a
    /// request of its own. The tags are grouped by area, each area with its own range.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        /// Acknowledges the onboarding
        #[prost(message, tag = "256")]
        Onboard(super::OnboardingResponse),
        /// Hardware and firmware versions of the Ark
        #[prost(message, tag = "257")]
        DeviceInfo(super::DeviceInfoResponse),
        /// Challenge for the cloud to sign along its time
        #[prost(message, tag = "258")]
        CloudSyncStart(super::CloudSyncStartResponse),
        /// Timestamp the Ark accepted from the cloud
        #[prost(message, tag = "259")]
        CloudSyncFinish(super::CloudSyncFinishResponse),
        /// Encrypted proof of the Ark's genuinity for the cloud
        #[prost(message, tag = "260")]
        GenuinityProof(super::GenuinityProofResponse),
        /// Ephemeral key to receive the firmware key with, sealed for the cloud
        #[prost(message, tag = "513")]
        FirmwareUpdatePrep(super::FirmwareUpdatePrepResponse),
        /// Acknowledges the initiated update
        #[prost(message, tag = "514")]
        FirmwareUpdateInit(super::FirmwareUpdateInitResponse),
        /// Acknowledges the appended firmware chunk
        #[prost(message, tag = "515")]
        FirmwareUpdateUpload(super::FirmwareUpdateUploadResponse),
        /// Acknowledges the verified firmware
        #[prost(message, tag = "516")]
        FirmwareUpdateVerify(super::FirmwareUpdateVerifyResponse),
        /// Acknowledges the installed firmware
        #[prost(message, tag = "517")]
        FirmwareUpdateInstall(super::FirmwareUpdateInstallResponse),
        /// Signed authorization for the cloud to open a rendezvous
        #[prost(message, tag = "769")]
        PairingAuth(super::PairingAuthResponse),
        /// Acknowledges the accepted app identity
        #[prost(message, tag = "770")]
        PairingSetAppId(super::PairingSetAppIdentityResponse),
        /// Ark device infos and key material, sealed for the app
        #[prost(message, tag = "771")]
        PairingSetAppStorage(super::PairingSetAppStorageResponse),
        /// Acknowledges the app's receipt of the Ark's keys
        #[prost(message, tag = "772")]
        PairingAckArkStorage(super::PairingAckArkStorageResponse),
        /// Signed confirmation that the user accepted the pairing
        #[prost(message, tag = "773")]
        PairingAccept(super::PairingAcceptanceResponse),
        /// Signed confirmation that the Ark finished pairing
        #[prost(message, tag = "774")]
        PairingComplete(super::PairingCompletionResponse),
        /// Signed authorization for the cloud to join the relay
        #[prost(message, tag = "1025")]
        RelayJoin(super::RelayJoinResponse),
        /// Confirms the Ark opened the frame
        #[prost(message, tag = "1026")]
        RelayInbound(super::RelayInboundResponse),
        /// Asks the host to write one frame to its relay socket
        #[prost(message, tag = "1027")]
        RelayOutbound(super::RelayOutboundRequest),
        /// Acknowledges the completed unlock
        #[prost(message, tag = "1281")]
        Unlock(super::UnlockResponse),
        /// Task id for the run's later messages
        #[prost(message, tag = "1282")]
        ExecUploadStart(super::ExecutionUploadStartResponse),
        /// Acknowledges the appended app chunk
        #[prost(message, tag = "1283")]
        ExecUploadChunk(super::ExecutionUploadChunkResponse),
        /// Acknowledges the authorized and started execution
        #[prost(message, tag = "1284")]
        ExecSched(super::ExecutionScheduleResponse),
        /// Where the scheduled run stands
        #[prost(message, tag = "1285")]
        ExecStatus(super::ExecutionStatusResponse),
        /// Acknowledges the canceled run or upload
        #[prost(message, tag = "1286")]
        ExecCancel(super::ExecutionCancelResponse),
        /// What the owner saw when releasing the output
        #[prost(message, tag = "1287")]
        ExecResult(super::ExecutionResultResponse),
        /// Next piece of the requested output stream
        #[prost(message, tag = "1288")]
        ExecOutput(super::ExecutionOutputResponse),
        /// Current state of every data slot
        #[prost(message, tag = "1537")]
        SlotList(super::SlotListResponse),
        /// Acknowledges the reset slot
        #[prost(message, tag = "1538")]
        SlotRepair(super::SlotRepairResponse),
        /// Acknowledges the deleted slot
        #[prost(message, tag = "1539")]
        SlotDelete(super::SlotDeleteResponse),
        /// Identification of the file's first chunk
        #[prost(message, tag = "1540")]
        SlotIdentify(super::SlotIdentifyResponse),
        /// Session id of the approved upload
        #[prost(message, tag = "1541")]
        SlotUploadStart(super::SlotUploadStartResponse),
        /// Acknowledges the appended slot chunk
        #[prost(message, tag = "1542")]
        SlotUploadChunk(super::SlotUploadChunkResponse),
        /// Acknowledges the aborted upload
        #[prost(message, tag = "1543")]
        SlotUploadCancel(super::SlotUploadCancelResponse),
        /// Processing progress of the completed upload
        #[prost(message, tag = "1544")]
        SlotUploadProcess(super::SlotUploadProcessResponse),
        /// Every path an app can read, with its description, format and examples
        #[prost(message, tag = "1793")]
        DatasetPaths(super::DatasetPathsResponse),
        /// Unreleased messages emitted by development firmware only, in response to
        /// a develop request, carried opaquely so the public protocol is untouched
        /// while they are still under development. Their schema is private.
        #[prost(bytes, tag = "4096")]
        Develop(::prost::alloc::vec::Vec<u8>),
    }
}
/// Error answers a failed request, in place of the response content.
///
/// Codes 0x00 through 0xff (inclusive) are reserved for protocol-wide errors.
/// Codes 0x100 and above are defined by the request type and may be reused
/// with different meanings for different requests. The message text is human
/// readable, not a stable code.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Error {
    /// Error code for programmatic interpretation
    #[prost(uint64, tag = "1")]
    pub code: u64,
    /// Error message for user interfacing
    #[prost(string, tag = "2")]
    pub msg: ::prost::alloc::string::String,
}
/// OnboardingRequest is a vendor utility to onboard an Ark. Currently it contains
/// the signed device genuinity attestation (certificate).
///
/// Note, as this method is only used during initial device setup, there is no API
/// compatibility guarantee, it will evolve with the factory tooling.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OnboardingRequest {
    /// Signed device genuinity attestation (CWT) to install
    #[prost(bytes = "vec", tag = "1")]
    pub device_attestation: ::prost::alloc::vec::Vec<u8>,
}
/// OnboardingResponse is the acknowledgement of the onboarding.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OnboardingResponse {}
/// DeviceInfoRequest is sent by the host to fetch the Ark's device stats.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeviceInfoRequest {}
/// DeviceInfoResponse returns various hardware and software version information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeviceInfoResponse {
    /// Ark device version (defines the major features)
    #[prost(uint32, tag = "1")]
    pub version_id: u32,
    /// Ark device version label (as known by the device)
    #[prost(string, tag = "2")]
    pub version_str: ::prost::alloc::string::String,
    /// Ark device revision (defines the minor differences)
    #[prost(uint32, tag = "3")]
    pub revision_id: u32,
    /// Ark device revision label (as known by the device)
    #[prost(string, tag = "4")]
    pub revision_str: ::prost::alloc::string::String,
    /// Current firmware version (X.Y.Z-commit)
    #[prost(string, tag = "7")]
    pub firmware_version: ::prost::alloc::string::String,
    /// Current firmware publish unix timestamp
    #[prost(uint64, tag = "8")]
    pub firmware_publish: u64,
    /// Whether a cloud identity was accepted since boot
    #[prost(bool, tag = "9")]
    pub cloud_synced: bool,
    /// Current device clock unix timestamp, set by the cloud sync
    #[prost(uint64, tag = "10")]
    pub cloud_clock: u64,
    /// Whether the Ark is paired with a companion app (user data initialized)
    #[prost(bool, tag = "11")]
    pub paired: bool,
    /// Whether the user data storage is open (false if unpaired)
    #[prost(bool, tag = "12")]
    pub unlocked: bool,
}
/// CloudSyncStartRequest requests the device to start a synchronization procedure
/// against the cloud servers to establish the current time as well as the currently
/// active cloud identity.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudSyncStartRequest {
    /// Post-quantum CWT attestation for the server signing (xDSA) key
    #[prost(bytes = "vec", tag = "1")]
    pub signer: ::prost::alloc::vec::Vec<u8>,
    /// Post-quantum CWT attestation for the server encryption (xHPKE) key
    #[prost(bytes = "vec", tag = "2")]
    pub crypto: ::prost::alloc::vec::Vec<u8>,
}
/// CloudSyncStartResponse is an initiation of a cloud sync from the device, authed
/// to the requested cloud identity.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudSyncStartResponse {
    /// Random nonce to avoid malicious host machines setting bad times
    #[prost(bytes = "vec", tag = "1")]
    pub challenge: ::prost::alloc::vec::Vec<u8>,
}
/// CloudSyncFinishRequest is the completion of a previously initiated cloud sync
/// procedure, this time being signed by a single identity currently used by the
/// cloud.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudSyncFinishRequest {
    /// Unix timestamp from the server in milliseconds
    #[prost(uint64, tag = "1")]
    pub unixmilli: u64,
    /// SignAt[Cloud]["cloudsync-v1"][unixmilli/1000](CBOR(challenge))
    #[prost(bytes = "vec", tag = "2")]
    pub signature: ::prost::alloc::vec::Vec<u8>,
}
/// CloudSyncFinishResponse is the acknowledgement whether the device accepted the
/// cloud sync from the server or rejected for some reason.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudSyncFinishResponse {
    /// Timestamp that was accepted and set
    #[prost(uint64, tag = "1")]
    pub accepted: u64,
}
/// GenuinityProofRequest requests the device to generate a cryptographic proof of
/// its own authenticity.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenuinityProofRequest {}
/// GenuinityProofResponse is the device genuinity proof, an encrypted signature
/// of the device.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenuinityProofResponse {
    /// Seal[Ark->Cloud]["genuinity-v1"][null](null)
    #[prost(bytes = "vec", tag = "1")]
    pub proof: ::prost::alloc::vec::Vec<u8>,
}
/// FirmwareUpdatePrepRequest prepares a firmware update procedure. If any previous
/// update procedure was in progress, it is aborted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdatePrepRequest {
    /// Version string to update to
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// SHA256 hash of the (encrypted) firmware archive
    #[prost(bytes = "vec", tag = "2")]
    pub sha256: ::prost::alloc::vec::Vec<u8>,
    /// Number of bytes (progress purposes, ignored otherwise)
    #[prost(uint64, tag = "3")]
    pub bytes: u64,
}
/// FirmwareUpdatePrepResponse confirms that a new firmware update procedure
/// started. A rejected request gets an error instead.
///
/// The Ark generates a fresh ephemeral encryption key to receive the firmware
/// access key. Its public half is sealed to the cloud, bound to the requested
/// version and hash.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdatePrepResponse {
    /// Seal[Ark->Cloud]["firmware-v1"][\[version, sha256\]](temp-key)
    #[prost(bytes = "vec", tag = "1")]
    pub auth: ::prost::alloc::vec::Vec<u8>,
}
/// FirmwareUpdateInitRequest initiates a previously prepared firmware update
/// procedure by providing the authenticated and encrypted firmware key.
///
/// Note, if the initiation is rejected, the entire update process is torn down.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateInitRequest {
    /// Seal[Cloud->temp-key]["firmware-v1"][\[version, sha256\]](sym-key)
    #[prost(bytes = "vec", tag = "1")]
    pub access: ::prost::alloc::vec::Vec<u8>,
}
/// FirmwareUpdateInitResponse acknowledges the initiated update procedure. A
/// rejected request gets an error instead.
///
/// Note, if the init is rejected, the entire update process is torn down.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateInitResponse {}
/// FirmwareUpdateUploadRequest requests appending a new chunk of data to the
/// currently pending firmware upload process.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateUploadRequest {
    /// Chunk of firmware blob to append (reasonably capped)
    #[prost(bytes = "vec", tag = "1")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
}
/// FirmwareUpdateUploadResponse is the response whether the requested chunk was
/// accepted or rejected.
///
/// Note, if the upload is rejected, the entire update process is torn down.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateUploadResponse {}
/// FirmwareUpdateVerifyRequest requests decrypting the uploaded firmware and
/// verifying its contents, preparing for the last step of actually installing
/// the firmware update.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateVerifyRequest {}
/// FirmwareUpdateVerifyResponse is the response whether the firmware just uploaded
/// passed all verifications and is ready for application.
///
/// Note, if the verification is rejected, the entire update process is torn down.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateVerifyResponse {}
/// FirmwareUpdateInstallRequest requests the currently pending (but already
/// verified) firmware to be applied to disk. This message will cause the device
/// to reboot if applied successfully.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateInstallRequest {}
/// FirmwareUpdateInstallResponse is the response whether the firmware was applied
/// successfully or not.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirmwareUpdateInstallResponse {}
/// PairingAuthRequest requests the initiation of a pairing.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAuthRequest {}
/// PairingAuthResponse responds whether the device is in a state compatible with
/// pairing (i.e. reset) and if so, it signs an authorization for the server to open
/// a new rendezvous point; containing the xHPKE public key to use for encrypting
/// messages to this Ark after pairing.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAuthResponse {
    /// Seal[Ark->Cloud]["pairing-v1"][null](pair-key)
    #[prost(bytes = "vec", tag = "1")]
    pub auth: ::prost::alloc::vec::Vec<u8>,
    /// Fingerprint of the pair-key to transmit to the app out-of-protocol
    #[prost(bytes = "vec", tag = "2")]
    pub fprint: ::prost::alloc::vec::Vec<u8>,
}
/// PairingSetAppIdentityRequest injects the companion app's identity, relayed
/// by the cloud.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingSetAppIdentityRequest {
    /// Seal[Cloud->Ark]["pairing-v1:identity"][\[ark_signer_id, ark_crypto_id\]](\[app_signer, app_crypto\])
    #[prost(bytes = "vec", tag = "1")]
    pub identity: ::prost::alloc::vec::Vec<u8>,
}
/// PairingSetAppIdentityResponse confirms whether the remote identity was
/// accepted by the Ark or not.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingSetAppIdentityResponse {}
/// PairingSetAppStorageRequest injects the app's storage key material into the
/// pairing flow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingSetAppStorageRequest {
    /// Seal[App->Ark]["pairing-v1:storage"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](\[app_keymat\])
    #[prost(bytes = "vec", tag = "1")]
    pub app_key: ::prost::alloc::vec::Vec<u8>,
}
/// PairingSetAppStorageResponse confirms whether the remote storage material
/// was accepted, and if so, bundles the ark device infos and ark key material.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingSetAppStorageResponse {
    /// 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\])
    #[prost(bytes = "vec", tag = "1")]
    pub ark_keys: ::prost::alloc::vec::Vec<u8>,
}
/// PairingAckArkStorageRequest confirms from the app that the Ark's key material
/// was received correctly.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAckArkStorageRequest {
    /// Seal[App->Ark]["pairing-v1:storage"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id, ark_keymat\]](null)
    #[prost(bytes = "vec", tag = "1")]
    pub app_ack: ::prost::alloc::vec::Vec<u8>,
}
/// PairingAckArkStorageResponse confirms that the key ack was accepted.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAckArkStorageResponse {}
/// PairingAcceptanceRequest is a blocking poller to wait until the user accepts
/// a pairing request or it times out.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAcceptanceRequest {}
/// PairingAcceptanceResponse returns whether the user accepted the pairing or
/// if it timed out. At this point, the device still needs to format itself.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingAcceptanceResponse {
    /// Seal[Ark->Cloud]["pairing-v1:accept"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](null)
    #[prost(bytes = "vec", tag = "1")]
    pub confirm: ::prost::alloc::vec::Vec<u8>,
}
/// PairingCompletionRequest is a blocking poller to wait until the device finishes
/// any pairing maintenance operation (e.g. encrypting itself).
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingCompletionRequest {}
/// PairingCompletionResponse returns whether the device finished preparing for
/// live operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PairingCompletionResponse {
    /// Seal[Ark->Cloud]["pairing-v1:complete"][\[ark_signer_id, ark_crypto_id, app_signer_id, app_crypto_id\]](null)
    #[prost(bytes = "vec", tag = "1")]
    pub confirm: ::prost::alloc::vec::Vec<u8>,
}
/// RelayJoinRequest requests authorization to join the communication relay with
/// the companion app.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayJoinRequest {}
/// RelayJoinResponse responds whether the device is in a state compatible with
/// relaying (i.e. paired) and if so, it signs an authorization for the server
/// to join the rendezvous point.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayJoinResponse {
    /// Seal[Ark->Cloud]["relaying-v2:join"][cloud_crypto_id](null)
    #[prost(bytes = "vec", tag = "1")]
    pub auth: ::prost::alloc::vec::Vec<u8>,
}
/// RelayInboundRequest forwards one frame from the host's relay socket to the Ark.
///
/// The relay connects the Ark with its companion app through the host and the
/// cloud. Its frames are opaque to the host, which forwards them unchanged in
/// both directions and never interprets them. Each frame is sealed to its
/// recipient by the other endpoint, or by the cloud itself, and its
/// authenticated data names the recipient's encryption key.
///
/// The host sends one request for each message its relay socket delivers, in
/// arrival order.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayInboundRequest {
    /// Seal[App|Cloud->Ark]["relaying-v2:frame"][ark_crypto_id](...)
    #[prost(bytes = "vec", tag = "1")]
    pub frame: ::prost::alloc::vec::Vec<u8>,
}
/// RelayInboundResponse confirms the Ark opened the frame, which decrypted and
/// verified. The Ark answers before acting on the frame's content, and refuses
/// a frame it cannot open with an error whose message names the cause.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayInboundResponse {}
/// RelayOutboundRequest asks the host to write one frame to its relay socket.
///
/// A host without a relay socket attaches one first through relay_join. If it
/// cannot, it answers with the reserved UNAVAILABLE error.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayOutboundRequest {
    /// Seal[Ark->App]["relaying-v2:frame"][app_crypto_id](...)
    #[prost(bytes = "vec", tag = "1")]
    pub frame: ::prost::alloc::vec::Vec<u8>,
}
/// RelayOutboundResponse confirms that the relay socket accepted the frame, which
/// does not mean the frame reached the app.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayOutboundResponse {}
/// UnlockRequest asks the Ark to open its user data storage.
///
/// The Ark answers once the owner approves or declines on their phone, or the
/// approval window runs out.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnlockRequest {}
/// UnlockResponse acknowledges the completed unlock. Any other outcome gets an
/// error instead.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnlockResponse {}
/// ExecutionUploadStartRequest begins a chunked upload of a WASM binary to
/// execute. The declared size is used to pre-allocate the receive buffer and
/// to reject oversized uploads early; the actual bytes are sent via subsequent
/// ExecutionUploadChunkRequest messages.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionUploadStartRequest {
    /// Total binary size in bytes
    #[prost(uint64, tag = "1")]
    pub bytes: u64,
}
/// ExecutionUploadStartResponse contains the task id for the run's later
/// messages. The task belongs to the session that opened it. When that session
/// ends, the Ark drops the task whatever its stage, canceling a running app.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionUploadStartResponse {
    /// Task id to stream chunks into
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
}
/// ExecutionUploadChunkRequest appends a chunk of data to a pending upload.
/// Chunks must be appended in order and must not overrun the declared size.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionUploadChunkRequest {
    /// Task id to append to
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
    /// Data chunk to append (reasonably capped)
    #[prost(bytes = "vec", tag = "2")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
}
/// ExecutionUploadChunkResponse is an empty ack of the chunk upload request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionUploadChunkResponse {}
/// ExecutionScheduleRequest finalizes an upload and requests the device to
/// execute the uploaded 3rd party app. The upload must have been completed
/// (i.e. the sum of chunk sizes matches the declared size).
///
/// The Ark answers once the owner approves or declines on their phone, or the
/// approval window runs out.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionScheduleRequest {
    /// Task id returned by ExecutionUploadStartResponse
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
}
/// ExecutionScheduleResponse acks that the execution was authorized and the
/// task is now running. The host already holds the task id from the preceding
/// ExecutionUploadStartResponse.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionScheduleResponse {}
/// ExecutionCancelRequest cancels an upload, a run awaiting the owner's
/// approval or a running app. An interrupted app's run fails and goes to the
/// owner's review like any other. A run that already ended cannot be canceled.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionCancelRequest {
    /// Task id to cancel
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
}
/// ExecutionCancelResponse acknowledges the canceled app run or upload.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionCancelResponse {}
/// ExecutionStatusRequest checks where a scheduled run stands. Only the session
/// that scheduled the run can check it.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionStatusRequest {
    /// Task id of the scheduled run
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
}
/// ExecutionStatusResponse reports where a scheduled run stands.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionStatusResponse {
    /// Where the run stands
    #[prost(enumeration = "ExecutionState", tag = "3")]
    pub state: i32,
}
/// ExecutionResultRequest fetches the result of a resolved run.
///
/// A released run answers with what the owner saw, the same until the run
/// closes for the host. A withheld run fails it with the reserved error its
/// report's approval closed with, and that failure closes the run.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionResultRequest {
    /// Task id of the resolved run
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
}
/// ExecutionResultResponse holds what the owner saw when releasing the run's
/// output, which the host then reads through ExecutionOutputRequest.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionResultResponse {
    /// App name from its manifest
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// App version from its manifest
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    /// Whether the app is a develop build
    #[prost(bool, tag = "3")]
    pub develop: bool,
    /// Whether the run succeeded
    #[prost(bool, tag = "4")]
    pub success: bool,
    /// Paths of the owner's data as mounted, without public grants
    #[prost(string, repeated, tag = "5")]
    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Media type of the report, such as text/markdown
    #[prost(string, tag = "6")]
    pub media: ::prost::alloc::string::String,
    /// Length in bytes of the report, the app's standard output
    #[prost(uint64, tag = "7")]
    pub stdout_bytes: u64,
    /// Length in bytes of a develop build's standard error, 0 otherwise
    #[prost(uint64, tag = "8")]
    pub stderr_bytes: u64,
}
/// ExecutionOutputRequest reads the next piece of a released run's output.
///
/// Each stream is read once and in order, in pieces of the size the host asks
/// for. The Ark refuses a size of zero, or one whose answer would not fit a
/// wire message. The run closes for the host once exec_result has answered and
/// both streams are read to their end.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionOutputRequest {
    /// Task id of the released run
    #[prost(uint64, tag = "1")]
    pub taskid: u64,
    /// Stream to read
    #[prost(enumeration = "ExecutionStream", tag = "2")]
    pub stream: i32,
    /// Bytes of the stream read so far, the only offset the Ark accepts
    #[prost(uint64, tag = "3")]
    pub offset: u64,
    /// Most bytes to return, chosen by the host
    #[prost(uint64, tag = "4")]
    pub size: u64,
}
/// ExecutionOutputResponse carries the next piece of the requested stream.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecutionOutputResponse {
    /// The requested bytes, fewer only at the stream's end
    #[prost(bytes = "vec", tag = "1")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
}
/// SlotDownload describes the public download the device advertises for a
/// reference slot, so a host can fetch it and stream it back in.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotDownload {
    /// Public download URL
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    /// Download size in bytes
    #[prost(uint64, tag = "2")]
    pub bytes: u64,
    /// Download SHA256 checksum
    #[prost(string, tag = "3")]
    pub sha256: ::prost::alloc::string::String,
}
/// SlotStatus describes the current state of a single slot on the device. The
/// data fields are generic so a host renders a kind it has never seen.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotStatus {
    /// Slot type
    #[prost(enumeration = "SlotKind", tag = "1")]
    pub kind: i32,
    /// Human-readable slot name
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Owner-facing description of the data this slot holds
    #[prost(string, tag = "3")]
    pub desc: ::prost::alloc::string::String,
    /// The file that fills this slot, its required shape and what is refused
    #[prost(string, tag = "4")]
    pub format: ::prost::alloc::string::String,
    /// Nature of the data (personal, reference)
    #[prost(enumeration = "SlotOrigin", tag = "5")]
    pub origin: i32,
    /// Whether the slot is empty, filled or damaged
    #[prost(enumeration = "SlotState", tag = "6")]
    pub state: i32,
    /// Why the slot is damaged, empty otherwise
    #[prost(string, tag = "7")]
    pub damage: ::prost::alloc::string::String,
    /// Slots that must be filled before this one is actionable
    #[prost(enumeration = "SlotKind", repeated, tag = "8")]
    pub deps: ::prost::alloc::vec::Vec<i32>,
    /// Bytes on disk for this slot (0 if empty)
    #[prost(uint64, tag = "9")]
    pub bytes: u64,
    /// Reference assembly the data is keyed to (e.g. "GRCh38.p14")
    #[prost(string, tag = "10")]
    pub build: ::prost::alloc::string::String,
    /// The dataset's own release, if it has one (e.g. dbSNP "157")
    #[prost(string, tag = "11")]
    pub version: ::prost::alloc::string::String,
    /// Advertised public download, absent if none
    #[prost(message, optional, tag = "12")]
    pub download: ::core::option::Option<SlotDownload>,
}
/// SlotListRequest requests the state of all slots on the device.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotListRequest {}
/// SlotListResponse contains the current state of every slot.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SlotListResponse {
    /// State of every slot, one entry per slot kind
    #[prost(message, repeated, tag = "1")]
    pub slots: ::prost::alloc::vec::Vec<SlotStatus>,
}
/// SlotRepairRequest resets a slot to empty regardless of its current state.
/// Unlike SlotDelete (which requires the slot to be filled), repair is a stateless
/// force cleanup that removes any leftover metadata and/or files on disk. It is
/// intended for recovering from corruption or half-written state after crashes.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotRepairRequest {
    /// Slot to repair (reset to empty)
    #[prost(enumeration = "SlotKind", tag = "1")]
    pub slot: i32,
}
/// SlotRepairResponse is an empty ack of the repair request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotRepairResponse {}
/// SlotDeleteRequest removes the contents of a filled slot. The slot must be
/// in a healthy, filled state; corrupted or half-written slots must be cleaned
/// up via SlotRepair instead.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotDeleteRequest {
    /// Slot to delete
    #[prost(enumeration = "SlotKind", tag = "1")]
    pub slot: i32,
}
/// SlotDeleteResponse is an empty ack of the delete request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotDeleteResponse {}
/// SlotIdentifyRequest sends an ephemeral file chunk to the Ark and asks it to
/// identify the file. Its purpose is to filter potentially huge files (e.g. a
/// 30GB compressed whole genome sequencing) before uploading them, and to
/// answer what a file is without uploading it at all.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotIdentifyRequest {
    /// File name to guess the contents of
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// File size to guess the contents of
    #[prost(uint64, tag = "2")]
    pub size: u64,
    /// First chunk of the file to guess the contents of
    #[prost(bytes = "vec", tag = "3")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
    /// Possible slots to interpret as (empty == any)
    #[prost(enumeration = "SlotKind", repeated, tag = "4")]
    pub kinds: ::prost::alloc::vec::Vec<i32>,
}
/// SlotIdentifyResponse contains the identification based on the chunk shared
/// in the request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotIdentifyResponse {
    /// Identified slot type to use during upload
    #[prost(enumeration = "SlotKind", tag = "1")]
    pub kind: i32,
    /// Identification confidence level
    #[prost(enumeration = "SlotConfidence", tag = "2")]
    pub conf: i32,
    /// Short summary of the identified data
    #[prost(string, tag = "3")]
    pub summary: ::prost::alloc::string::String,
    /// Detailed description of the identified data
    #[prost(string, tag = "4")]
    pub details: ::prost::alloc::string::String,
    /// Reason why the file is rejected, empty otherwise
    #[prost(string, tag = "5")]
    pub rejection: ::prost::alloc::string::String,
}
/// SlotUploadStartRequest requests uploading a file into a slot of the given
/// kind (e.g. a whole genome variant call file).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadStartRequest {
    /// Slot type requesting to upload
    #[prost(enumeration = "SlotKind", tag = "1")]
    pub kind: i32,
    /// File name to guess the contents of
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// File size to guess the contents of
    #[prost(uint64, tag = "3")]
    pub size: u64,
    /// First chunk of the file to guess the contents of
    #[prost(bytes = "vec", tag = "4")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
}
/// SlotUploadStartResponse contains a unique session id for an approved upload.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadStartResponse {
    /// Session id for concurrent uploads (not recommended)
    #[prost(uint64, tag = "1")]
    pub session: u64,
}
/// SlotUploadChunkRequest contains a new chunk of data to append to a pending
/// upload session.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadChunkRequest {
    /// Session id into which to append a new chunk
    #[prost(uint64, tag = "1")]
    pub session: u64,
    /// Data chunk to append (reasonably capped)
    #[prost(bytes = "vec", tag = "2")]
    pub chunk: ::prost::alloc::vec::Vec<u8>,
}
/// SlotUploadChunkResponse is an empty ack of the chunk upload request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadChunkResponse {}
/// SlotUploadCancelRequest contains an upload session id to abort.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadCancelRequest {
    /// Session id to cancel
    #[prost(uint64, tag = "1")]
    pub session: u64,
}
/// SlotUploadCancelResponse is an empty ack of the cancellation request.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadCancelResponse {}
/// SlotPhase names one step of a slot's processing pipeline.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotPhase {
    /// Short label for the phase
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Description of what the phase does
    #[prost(string, tag = "2")]
    pub desc: ::prost::alloc::string::String,
}
/// SlotUploadProcessRequest marks an upload session ready for processing and
/// requests a progress report to be sent back. May be called multiple times.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlotUploadProcessRequest {
    /// Session id to mark as completed
    #[prost(uint64, tag = "1")]
    pub session: u64,
}
/// SlotUploadProcessResponse acks the completion of a slot upload and also
/// contains the current processing progress.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SlotUploadProcessResponse {
    /// Unix timestamp when data processing started
    #[prost(uint64, tag = "1")]
    pub proc_start: u64,
    /// Every phase of the pipeline, in order
    #[prost(message, repeated, tag = "2")]
    pub phases: ::prost::alloc::vec::Vec<SlotPhase>,
    /// Current phase (1-indexed)
    #[prost(uint64, tag = "3")]
    pub phase_in: u64,
    /// Unix timestamp when the current phase started
    #[prost(uint64, tag = "4")]
    pub phase_start: u64,
    /// Approximate progress for this phase \[0-10000\]
    #[prost(uint64, tag = "5")]
    pub phase_progress: u64,
    /// Failure reason if processing failed, empty otherwise
    #[prost(string, tag = "6")]
    pub failure: ::prost::alloc::string::String,
}
/// DatasetPathsRequest requests the map of every path an app can read, the
/// dataset view the device derives from its slots, lenses included.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DatasetPathsRequest {}
/// DatasetPathsResponse maps every path an app can read, available or not, in
/// tree order. It describes the tree only and never carries a value from the
/// owner's data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetPathsResponse {
    /// Every path pattern, in tree order
    #[prost(message, repeated, tag = "1")]
    pub paths: ::prost::alloc::vec::Vec<DatasetPath>,
}
/// DatasetPath describes one path pattern under the data root. A segment in angle
/// brackets is a placeholder, described by the directory entry it names. The path
/// is the entry's stable key.
///
/// A grantable path also carries whether it reads only public data, which is the
/// same on every Ark, and its wording. The wording is an English template that
/// describes a grant to the owner, with each placeholder named after the path's
/// own, such as "Your genotype at {rsid}".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DatasetPath {
    /// Path as a manifest names it
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// Directory or file
    #[prost(bool, tag = "2")]
    pub directory: bool,
    /// Whether a manifest may name it
    #[prost(bool, tag = "3")]
    pub grantable: bool,
    /// Whether the data this path needs is on the Ark now
    #[prost(bool, tag = "4")]
    pub available: bool,
    /// What it holds, when it is absent and when it fails
    #[prost(string, tag = "5")]
    pub desc: ::prost::alloc::string::String,
    /// Exact file content, or what a directory lists
    #[prost(string, tag = "6")]
    pub format: ::prost::alloc::string::String,
    /// Complete example values, most typical first
    #[prost(string, repeated, tag = "7")]
    pub examples: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Whether a grant reads only public data, for grantable paths
    #[prost(bool, tag = "8")]
    pub public: bool,
    /// Template wording a grant to the owner, for grantable paths
    #[prost(string, tag = "9")]
    pub wording: ::prost::alloc::string::String,
}
/// ReservedErrors names the assigned protocol-wide errors in the reserved range
/// 0x00 to 0xff (inclusive). No code in this range may be assigned a request
/// specific meaning. Assigned codes must not be repurposed.
#[non_exhaustive]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ReservedErrors {
    /// A failure without a standardized reason. Zero does not indicate success;
    /// the presence of an Error in the response indicates failure.
    Unspecified = 0,
    /// The request's responder was released without providing an application reply.
    Unanswered = 1,
    /// The peer does not know this request. Emitted by the protocol layer itself
    /// when a request's content is not in its schema.
    Unknown = 2,
    /// The peer knows this request but never serves it in this build or role,
    /// firmware updates on an emulator or develop envelopes on production.
    Unsupported = 3,
    /// The peer serves this request but not in its current state, before cloud
    /// sync or pairing. It may once the state changes.
    Unavailable = 4,
    /// The peer serves this request but the phone approval it depends on did not
    /// authorize it. The owner declined, or the phone's answer broke the approval's
    /// rules and counts as a decline.
    Unauthorized = 5,
    /// The peer serves this request but the approval it depends on did not arrive
    /// before its window ran out, on the phone or at the button.
    Unconfirmed = 6,
    /// The peer serves this request but the approval it depends on could not be
    /// sent to the phone, since the relay failed on the way.
    Undelivered = 7,
}
impl ReservedErrors {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "RESERVED_ERRORS_UNSPECIFIED",
            Self::Unanswered => "RESERVED_ERRORS_UNANSWERED",
            Self::Unknown => "RESERVED_ERRORS_UNKNOWN",
            Self::Unsupported => "RESERVED_ERRORS_UNSUPPORTED",
            Self::Unavailable => "RESERVED_ERRORS_UNAVAILABLE",
            Self::Unauthorized => "RESERVED_ERRORS_UNAUTHORIZED",
            Self::Unconfirmed => "RESERVED_ERRORS_UNCONFIRMED",
            Self::Undelivered => "RESERVED_ERRORS_UNDELIVERED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RESERVED_ERRORS_UNSPECIFIED" => Some(Self::Unspecified),
            "RESERVED_ERRORS_UNANSWERED" => Some(Self::Unanswered),
            "RESERVED_ERRORS_UNKNOWN" => Some(Self::Unknown),
            "RESERVED_ERRORS_UNSUPPORTED" => Some(Self::Unsupported),
            "RESERVED_ERRORS_UNAVAILABLE" => Some(Self::Unavailable),
            "RESERVED_ERRORS_UNAUTHORIZED" => Some(Self::Unauthorized),
            "RESERVED_ERRORS_UNCONFIRMED" => Some(Self::Unconfirmed),
            "RESERVED_ERRORS_UNDELIVERED" => Some(Self::Undelivered),
            _ => None,
        }
    }
}
/// ExecutionState is where a scheduled run stands for its host.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ExecutionState {
    /// Never sent, an unset state
    Unspecified = 0,
    /// The app still runs
    Running = 1,
    /// The run ended and the owner reviews its report
    Awaiting = 2,
    /// The review closed, so exec_result answers
    Resolved = 3,
}
impl ExecutionState {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "EXECUTION_STATE_UNSPECIFIED",
            Self::Running => "EXECUTION_STATE_RUNNING",
            Self::Awaiting => "EXECUTION_STATE_AWAITING",
            Self::Resolved => "EXECUTION_STATE_RESOLVED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EXECUTION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
            "EXECUTION_STATE_RUNNING" => Some(Self::Running),
            "EXECUTION_STATE_AWAITING" => Some(Self::Awaiting),
            "EXECUTION_STATE_RESOLVED" => Some(Self::Resolved),
            _ => None,
        }
    }
}
/// ExecutionStream names one output stream of a run.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ExecutionStream {
    /// Never sent, an unset stream
    Unspecified = 0,
    /// Standard output, the report
    Stdout = 1,
    /// Standard error, kept for develop builds only
    Stderr = 2,
}
impl ExecutionStream {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "EXECUTION_STREAM_UNSPECIFIED",
            Self::Stdout => "EXECUTION_STREAM_STDOUT",
            Self::Stderr => "EXECUTION_STREAM_STDERR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EXECUTION_STREAM_UNSPECIFIED" => Some(Self::Unspecified),
            "EXECUTION_STREAM_STDOUT" => Some(Self::Stdout),
            "EXECUTION_STREAM_STDERR" => Some(Self::Stderr),
            _ => None,
        }
    }
}
/// SlotKind identifies a slot on the device. Each value corresponds to a unique
/// data type that the device can store and manage.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SlotKind {
    /// Never sent, an unset kind
    Unspecified = 0,
    /// Human reference genome assembly
    ReferenceGenome = 1,
    /// Gene-to-coordinate mapping database
    GeneAnnotations = 2,
    /// User's SNP/indel variant calls
    SnpIndelCalls = 3,
    /// Variant catalog (rsID-to-position), from dbSNP
    VariantCatalog = 4,
}
impl SlotKind {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SLOT_KIND_UNSPECIFIED",
            Self::ReferenceGenome => "SLOT_KIND_REFERENCE_GENOME",
            Self::GeneAnnotations => "SLOT_KIND_GENE_ANNOTATIONS",
            Self::SnpIndelCalls => "SLOT_KIND_SNP_INDEL_CALLS",
            Self::VariantCatalog => "SLOT_KIND_VARIANT_CATALOG",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SLOT_KIND_UNSPECIFIED" => Some(Self::Unspecified),
            "SLOT_KIND_REFERENCE_GENOME" => Some(Self::ReferenceGenome),
            "SLOT_KIND_GENE_ANNOTATIONS" => Some(Self::GeneAnnotations),
            "SLOT_KIND_SNP_INDEL_CALLS" => Some(Self::SnpIndelCalls),
            "SLOT_KIND_VARIANT_CATALOG" => Some(Self::VariantCatalog),
            _ => None,
        }
    }
}
/// SlotOrigin describes the nature of the data in a slot, determining what
/// actions are available to the user for filling it.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SlotOrigin {
    /// Never sent, an unset origin
    Unspecified = 0,
    /// Unique to the user, uploaded by them
    Personal = 1,
    /// Standard reference data, downloaded from public sources
    Reference = 2,
}
impl SlotOrigin {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SLOT_ORIGIN_UNSPECIFIED",
            Self::Personal => "SLOT_ORIGIN_PERSONAL",
            Self::Reference => "SLOT_ORIGIN_REFERENCE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SLOT_ORIGIN_UNSPECIFIED" => Some(Self::Unspecified),
            "SLOT_ORIGIN_PERSONAL" => Some(Self::Personal),
            "SLOT_ORIGIN_REFERENCE" => Some(Self::Reference),
            _ => None,
        }
    }
}
/// SlotState describes whether a slot holds data and whether that data is sound.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SlotState {
    /// Never sent, an unset state
    Unspecified = 0,
    /// Nothing stored
    Empty = 1,
    /// Data present and healthy
    Filled = 2,
    /// Files exist but the metadata is missing, corrupt or outdated
    Damaged = 3,
}
impl SlotState {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SLOT_STATE_UNSPECIFIED",
            Self::Empty => "SLOT_STATE_EMPTY",
            Self::Filled => "SLOT_STATE_FILLED",
            Self::Damaged => "SLOT_STATE_DAMAGED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SLOT_STATE_UNSPECIFIED" => Some(Self::Unspecified),
            "SLOT_STATE_EMPTY" => Some(Self::Empty),
            "SLOT_STATE_FILLED" => Some(Self::Filled),
            "SLOT_STATE_DAMAGED" => Some(Self::Damaged),
            _ => None,
        }
    }
}
/// SlotConfidence indicates how confident the device is in its identification
/// of a file, based on content, filename and size.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SlotConfidence {
    /// Never sent, an unset confidence
    Unspecified = 0,
    /// Filename/extension only, no content confirmation
    Low = 1,
    /// Format detected but slot type inferred from size/filename
    Mid = 2,
    /// Magic bytes match and format-specific content confirmed
    High = 3,
}
impl SlotConfidence {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SLOT_CONFIDENCE_UNSPECIFIED",
            Self::Low => "SLOT_CONFIDENCE_LOW",
            Self::Mid => "SLOT_CONFIDENCE_MID",
            Self::High => "SLOT_CONFIDENCE_HIGH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SLOT_CONFIDENCE_UNSPECIFIED" => Some(Self::Unspecified),
            "SLOT_CONFIDENCE_LOW" => Some(Self::Low),
            "SLOT_CONFIDENCE_MID" => Some(Self::Mid),
            "SLOT_CONFIDENCE_HIGH" => Some(Self::High),
            _ => None,
        }
    }
}