use std::fmt;
use lgwks_std::json::serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
#[serde(rename_all = "lowercase")]
pub enum Capability {
#[serde(rename = "signal.emit")]
SignalEmit,
#[serde(rename = "signal.subscribe")]
SignalSubscribe,
#[serde(rename = "tape.read")]
TapeRead,
#[serde(rename = "view.inject")]
ViewInject,
#[serde(rename = "intent.emit")]
IntentEmit,
#[serde(rename = "motion.schedule")]
MotionSchedule,
#[serde(rename = "motion.observe")]
MotionObserve,
#[serde(rename = "motion.patch")]
MotionPatch,
#[serde(rename = "motion.plugin.register")]
MotionPluginRegister,
#[serde(rename = "motion.replay")]
MotionReplay,
#[serde(rename = "efface.shred")]
Shred,
#[serde(rename = "efface.rtbf")]
Rtbf,
#[serde(rename = "compute.remote")]
RemoteCompute,
}
impl fmt::Display for Capability {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let text = match *self {
Self::SignalEmit => "signal.emit",
Self::SignalSubscribe => "signal.subscribe",
Self::TapeRead => "tape.read",
Self::ViewInject => "view.inject",
Self::IntentEmit => "intent.emit",
Self::MotionSchedule => "motion.schedule",
Self::MotionObserve => "motion.observe",
Self::MotionPatch => "motion.patch",
Self::MotionPluginRegister => "motion.plugin.register",
Self::MotionReplay => "motion.replay",
Self::Shred => "efface.shred",
Self::Rtbf => "efface.rtbf",
Self::RemoteCompute => "compute.remote",
};
formatter.write_str(text)
}
}
impl std::str::FromStr for Capability {
type Err = &'static str;
fn from_str(text: &str) -> Result<Self, Self::Err> {
match text {
"signal.emit" => Ok(Self::SignalEmit),
"signal.subscribe" => Ok(Self::SignalSubscribe),
"tape.read" => Ok(Self::TapeRead),
"view.inject" => Ok(Self::ViewInject),
"intent.emit" => Ok(Self::IntentEmit),
"motion.schedule" => Ok(Self::MotionSchedule),
"motion.observe" => Ok(Self::MotionObserve),
"motion.patch" => Ok(Self::MotionPatch),
"motion.plugin.register" => Ok(Self::MotionPluginRegister),
"motion.replay" => Ok(Self::MotionReplay),
"efface.shred" => Ok(Self::Shred),
"efface.rtbf" => Ok(Self::Rtbf),
"compute.remote" => Ok(Self::RemoteCompute),
_ => Err("unknown capability"),
}
}
}
impl Capability {
#[must_use]
pub fn all() -> [Self; 13] {
[
Self::SignalEmit,
Self::SignalSubscribe,
Self::TapeRead,
Self::ViewInject,
Self::IntentEmit,
Self::MotionSchedule,
Self::MotionObserve,
Self::MotionPatch,
Self::MotionPluginRegister,
Self::MotionReplay,
Self::Shred,
Self::Rtbf,
Self::RemoteCompute,
]
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde", rename_all = "lowercase")]
#[non_exhaustive]
pub enum EgressDestination {
CloudRelay,
AuditVault,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum ActorType {
Human,
Agent,
System,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum TrustBin {
System,
Managed,
Generated,
Untrusted,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum LocalActionStatus {
Pending,
Running,
Completed,
Failed,
Compensating,
Compensated,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum SyncStatus {
NotSynced,
Uploading,
Acknowledged,
ConflictDetected,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum CompensationStrategy {
None,
Rollback,
Compensate,
Abandon,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub enum OfflineBehavior {
QueueLocally,
FailClosed,
DegradeToCache,
Unsupported,
}