agent-workspace-contract 0.1.0

use anyhow::Result;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Debug;
use std::sync::Arc;

mod base64_bytes {
    use base64::{Engine as _, engine::general_purpose::STANDARD};
    use serde::{Deserialize, Deserializer, Serializer};

    pub fn serialize<S>(value: &[u8], serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&STANDARD.encode(value))
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let value = String::deserialize(deserializer)?;
        STANDARD.decode(value).map_err(serde::de::Error::custom)
    }
}

mod ports;
pub use ports::*;

mod resources;
pub use resources::*;

pub const COMPUTERS_PATH: &str = "/internal/v1/computers";
pub const COMPUTER_PATH: &str = "/internal/v1/computers/{computerId}";
pub const COMPUTER_BIND_PATH: &str = "/internal/v1/computers/{computerId}/bind";
pub const COMPUTER_BINDING_PATH: &str = "/internal/v1/computers/{computerId}/binding";
pub const COMPUTER_RELEASE_PATH: &str = "/internal/v1/computers/{computerId}/release";
pub const SPACES_PATH: &str = "/internal/v1/spaces";
pub const SPACE_PATH: &str = "/internal/v1/spaces/{spaceId}";
pub const SPACE_GRANTS_PATH: &str = "/internal/v1/spaces/{spaceId}/grants";
pub const SPACE_GRANT_REVOKE_PATH: &str = "/internal/v1/spaces/{spaceId}/grants/{grantId}/revoke";
pub const SPACE_SESSIONS_PATH: &str = "/internal/v1/spaces/{spaceId}/sessions";
pub const SPACE_SESSION_HEARTBEAT_PATH: &str = "/internal/v1/space-sessions/{sessionId}/heartbeat";
pub const SPACE_SESSION_CLOSE_PATH: &str = "/internal/v1/space-sessions/{sessionId}/close";
pub const SPACE_TICKETS_PATH: &str = "/internal/v1/space-access-tickets";
pub const SPACE_LEASES_PATH: &str = "/internal/v1/spaces/{spaceId}/leases";
pub const SPACE_LEASE_PATH: &str = "/internal/v1/spaces/{spaceId}/leases/{leaseId}";
pub const SPACE_FILES_PATH: &str = "/internal/v1/spaces/{spaceId}/files/{*filePath}";
pub const SPACE_FILES_READ_PATH: &str = "/internal/v1/spaces/{spaceId}/files/read";
pub const SPACE_CHANGE_SETS_PATH: &str = "/internal/v1/spaces/{spaceId}/change-sets";
pub const SPACE_CHANGE_SET_APPLY_PATH: &str =
    "/internal/v1/spaces/{spaceId}/change-sets/{changeSetId}/apply";
pub const SANDBOXES_PATH: &str = "/internal/v1/sandboxes";
pub const SANDBOX_PATH: &str = "/internal/v1/sandboxes/{sandboxId}";
pub const SANDBOX_STOP_PATH: &str = "/internal/v1/sandboxes/{sandboxId}/stop";
pub const SNAPSHOTS_PATH: &str = "/internal/v1/snapshots";
pub const SNAPSHOT_PATH: &str = "/internal/v1/snapshots/{snapshotId}";
pub const TEMPLATES_PATH: &str = "/internal/v1/templates";
pub const TEMPLATE_VERSIONS_PATH: &str = "/internal/v1/templates/{templateId}/versions";
pub const TEMPLATE_VERSION_PATH: &str = "/internal/v1/templates/{templateId}/versions/{version}";
pub const TEMPLATE_VERSION_PUBLISH_PATH: &str =
    "/internal/v1/templates/{templateId}/versions/{version}/publish";
pub const TEMPLATE_VERSION_DEPRECATE_PATH: &str =
    "/internal/v1/templates/{templateId}/versions/{version}/deprecate";
pub const DELEGATIONS_PATH: &str = "/internal/v1/delegations";
pub const DELEGATION_REVOKE_PATH: &str = "/internal/v1/delegations/{delegationId}/revoke";
pub const ENVIRONMENT_MAX_FILE_BYTES: usize = 8 * 1024 * 1024;
pub const ENVIRONMENT_MAX_PATH_BYTES: usize = 4096;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum EnvironmentErrorCode {
    NotFound,
    Forbidden,
    Conflict,
    InvalidState,
    CapabilityUnsupported,
    TicketExpired,
    LeaseRequired,
    StaleFencingToken,
    RevisionConflict,
}

#[derive(Debug, Clone)]
pub struct EnvironmentDomainError {
    pub code: EnvironmentErrorCode,
    pub message: String,
}

impl EnvironmentDomainError {
    pub fn new(code: EnvironmentErrorCode, message: impl Into<String>) -> Self {
        Self {
            code,
            message: message.into(),
        }
    }
}

impl std::fmt::Display for EnvironmentDomainError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter.write_str(&self.message)
    }
}

impl std::error::Error for EnvironmentDomainError {}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PrincipalKind {
    User,
    Agent,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct PrincipalRef {
    pub kind: PrincipalKind,
    pub id: String,
}

impl PrincipalRef {
    pub fn user(id: impl Into<String>) -> Self {
        Self {
            kind: PrincipalKind::User,
            id: id.into(),
        }
    }

    pub fn agent(id: impl Into<String>) -> Self {
        Self {
            kind: PrincipalKind::Agent,
            id: id.into(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ResourceScope {
    pub tenant_id: String,
    pub project_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ProviderResourceRef {
    pub provider: String,
    pub external_id: String,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ProviderCapabilities {
    #[serde(default)]
    pub capabilities: BTreeSet<String>,
}

impl ProviderCapabilities {
    pub fn supports(&self, capability: &str) -> bool {
        self.capabilities.contains(capability)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ComputerLifecycle {
    Ready,
    Deleted,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ComputerRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub provider_ref: ProviderResourceRef,
    pub lifecycle: ComputerLifecycle,
    pub capabilities: ProviderCapabilities,
    /// Principal allowed to perform the initial bind and lifecycle management.
    /// Creating a Computer and binding it remain separate transitions.
    pub created_by: PrincipalRef,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ComputerBinding {
    pub computer_id: String,
    pub principal: PrincipalRef,
    pub role: String,
    pub active: bool,
    pub bound_at_ms: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub released_at_ms: Option<u64>,
    pub version: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpacePersistence {
    Persistent,
    CopyOnWrite,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpaceLifecycle {
    Ready,
    Deleted,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub provider_ref: ProviderResourceRef,
    pub persistence: SpacePersistence,
    pub lifecycle: SpaceLifecycle,
    pub capabilities: ProviderCapabilities,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_snapshot_id: Option<String>,
    pub revision: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SandboxPlacement {
    Computer(String),
    ProviderPool(String),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SandboxLifecycle {
    Ready,
    Stopped,
    Expired,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SandboxMount {
    pub alias: String,
    pub space_id: String,
    pub mode: SpaceAccessMode,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path_prefix: Option<String>,
    pub access_ticket_token: String,
}

/// Persisted mount metadata. The bearer token from [`SandboxMount`] is
/// deliberately replaced by its non-secret ticket id before persistence.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SandboxMountRecord {
    pub alias: String,
    pub space_id: String,
    pub mode: SpaceAccessMode,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path_prefix: Option<String>,
    pub access_ticket_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SandboxRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub provider_ref: ProviderResourceRef,
    pub placement: SandboxPlacement,
    pub lifecycle: SandboxLifecycle,
    pub owner: PrincipalRef,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub access_delegation_id: Option<String>,
    pub capabilities: ProviderCapabilities,
    #[serde(default)]
    pub mounts: Vec<SandboxMountRecord>,
    pub expires_at_ms: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SnapshotLifecycle {
    Ready,
    Deleted,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SnapshotSourceRecord {
    Computer { computer_id: String },
    Sandbox { sandbox_id: String },
    Space { space_id: String, revision: u64 },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SnapshotRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub provider_ref: ProviderResourceRef,
    pub source: SnapshotSourceRecord,
    pub created_by: PrincipalRef,
    pub lifecycle: SnapshotLifecycle,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub digest: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<u64>,
    pub created_at_ms: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TemplateTarget {
    Computer,
    Sandbox,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TemplateVersionState {
    Draft,
    Published,
    Deprecated,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct TemplateVersionRecord {
    pub template_id: String,
    pub version: String,
    pub scope: ResourceScope,
    pub provider: String,
    pub created_by: PrincipalRef,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_template_id: Option<String>,
    pub target: TemplateTarget,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub base_snapshot_id: Option<String>,
    #[serde(default)]
    pub resource_profile: BTreeMap<String, String>,
    #[serde(default)]
    pub parameter_schema: BTreeMap<String, String>,
    pub state: TemplateVersionState,
    pub created_at_ms: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpaceCapability {
    Read,
    Write,
    Share,
    Manage,
    Mount,
    Snapshot,
    Restore,
    Delete,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceGrant {
    pub id: String,
    pub scope: ResourceScope,
    pub space_id: String,
    pub principal: PrincipalRef,
    pub capabilities: BTreeSet<SpaceCapability>,
    #[serde(default)]
    pub path_prefixes: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at_ms: Option<u64>,
    pub active: bool,
    pub version: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpaceAccessMode {
    ReadOnly,
    DirectWrite,
    CopyOnWrite,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpaceSessionLifecycle {
    Opening,
    Active,
    Closing,
    Closed,
    Expired,
    Revoked,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceCollaborationSession {
    pub id: String,
    pub scope: ResourceScope,
    pub space_id: String,
    pub principal: PrincipalRef,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_id: Option<String>,
    pub requested_mode: SpaceAccessMode,
    pub effective_mode: SpaceAccessMode,
    pub lifecycle: SpaceSessionLifecycle,
    pub last_heartbeat_at_ms: u64,
    pub expires_at_ms: u64,
    pub version: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceAccessTicketRecord {
    pub id: String,
    pub token_hash: String,
    pub scope: ResourceScope,
    pub space_id: String,
    pub session_id: String,
    pub mode: SpaceAccessMode,
    /// Capability-specific path rules captured at issue time. Runtime
    /// intersects these with current Grant/Delegation authority on every use.
    #[serde(default)]
    pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fencing_token: Option<u64>,
    pub expires_at_ms: u64,
    pub revoked: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct IssuedSpaceAccessTicket {
    pub ticket: SpaceAccessTicketRecord,
    /// Returned exactly once. Repositories and logs must never persist this
    /// bearer value.
    pub token: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceWriteLease {
    pub id: String,
    pub scope: ResourceScope,
    pub space_id: String,
    pub session_id: String,
    pub fencing_token: u64,
    pub version: u64,
    pub acquired_at_ms: u64,
    pub expires_at_ms: u64,
    pub active: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct DelegationRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub grantor_user_id: String,
    pub delegate_agent_id: String,
    #[serde(default)]
    pub computer_ids: BTreeSet<String>,
    #[serde(default)]
    pub space_ids: BTreeSet<String>,
    pub capabilities: BTreeSet<SpaceCapability>,
    #[serde(default)]
    pub path_prefixes: Vec<String>,
    pub purpose: String,
    pub expires_at_ms: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revoked_at_ms: Option<u64>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChangeSetLifecycle {
    Ready,
    Applied,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceChangeSetRecord {
    pub id: String,
    pub scope: ResourceScope,
    pub source_space_id: String,
    pub target_space_id: String,
    pub base_revision: u64,
    pub created_by_session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_change_ref: Option<String>,
    pub lifecycle: ChangeSetLifecycle,
    pub created_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateComputerRequest {
    pub provider: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template_version: Option<String>,
    #[serde(default)]
    pub profile: BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateSpaceRequest {
    pub provider: String,
    pub persistence: SpacePersistence,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_snapshot_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateSandboxRequest {
    pub provider: String,
    pub placement: SandboxPlacement,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_id: Option<String>,
    pub ttl_ms: u64,
    #[serde(default)]
    pub mounts: Vec<SandboxMount>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_snapshot_id: Option<String>,
    #[serde(default)]
    pub profile: BTreeMap<String, String>,
}

/// Provider-facing request after product identifiers and access tickets have
/// been resolved. These DTOs cannot be supplied by HTTP callers.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderComputerRequest {
    pub template_external_id: Option<String>,
    pub profile: BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderSpaceRequest {
    pub persistence: SpacePersistence,
    pub source_snapshot_external_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderSandboxMount {
    pub alias: String,
    pub space_external_id: String,
    pub mode: SpaceAccessMode,
    pub path_prefix: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProviderSandboxPlacement {
    Computer(String),
    ProviderPool(String),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderSandboxRequest {
    pub placement: ProviderSandboxPlacement,
    pub ttl_ms: u64,
    pub mounts: Vec<ProviderSandboxMount>,
    pub template_external_id: Option<String>,
    pub source_snapshot_external_id: Option<String>,
    pub profile: BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProviderSnapshotSource {
    Computer(String),
    Sandbox(String),
    Space(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct BindComputerRequest {
    pub principal: PrincipalRef,
    #[serde(default = "default_primary_role")]
    pub role: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ReleaseComputerBindingRequest {
    pub expected_version: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RevokeSpaceGrantRequest {
    pub expected_version: u64,
}

fn default_primary_role() -> String {
    "primary".to_string()
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateSpaceGrantRequest {
    pub principal: PrincipalRef,
    pub capabilities: BTreeSet<SpaceCapability>,
    #[serde(default)]
    pub path_prefixes: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at_ms: Option<u64>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct OpenSpaceSessionRequest {
    pub mode: SpaceAccessMode,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_id: Option<String>,
    pub ttl_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct IssueSpaceAccessTicketRequest {
    pub session_id: String,
    pub ttl_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AcquireSpaceWriteLeaseRequest {
    pub session_id: String,
    pub ttl_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ReleaseSpaceWriteLeaseRequest {
    pub session_id: String,
    pub fencing_token: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct HeartbeatSpaceSessionRequest {
    pub ttl_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateDelegationRequest {
    pub delegate_agent_id: String,
    #[serde(default)]
    pub computer_ids: BTreeSet<String>,
    #[serde(default)]
    pub space_ids: BTreeSet<String>,
    pub capabilities: BTreeSet<SpaceCapability>,
    #[serde(default)]
    pub path_prefixes: Vec<String>,
    pub purpose: String,
    pub expires_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum CreateSnapshotSource {
    Computer {
        computer_id: String,
    },
    Sandbox {
        sandbox_id: String,
    },
    Space {
        space_id: String,
        session_id: String,
        access_ticket_token: String,
    },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateSnapshotResourceRequest {
    pub source: CreateSnapshotSource,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateTemplateVersionRequest {
    pub template_id: String,
    pub version: String,
    pub provider: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_template_id: Option<String>,
    pub target: TemplateTarget,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub base_snapshot_id: Option<String>,
    #[serde(default)]
    pub resource_profile: BTreeMap<String, String>,
    #[serde(default)]
    pub parameter_schema: BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct CreateSpaceChangeSetRequest {
    pub source_space_id: String,
    pub target_space_id: String,
    pub created_by_session_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ApplySpaceChangeSetRequest {
    pub access_ticket_token: String,
    pub fencing_token: u64,
    pub expected_revision: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct WriteSpaceFileRequest {
    pub access_ticket_token: String,
    pub fencing_token: u64,
    pub expected_revision: u64,
    #[serde(with = "base64_bytes")]
    pub content: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ReadSpaceFileRequest {
    pub access_ticket_token: String,
    pub path: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ProviderFileContent {
    pub bytes: Vec<u8>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_revision: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ProviderWriteResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_revision: Option<String>,
}