fundaia 0.26.0

// Some of these fields are decoded and never read. That is the point: this
// module is the wire contract written down, and a field that is dropped from
// the struct is a field the next command has to rediscover from the server's
// source. The cost of keeping them is one `#[allow]`; the cost of trimming them
// to whatever is used today is paid every time the tool grows a subcommand.
#![allow(dead_code)]

use serde::{Deserialize, Serialize};

/// The DTOs the server sends, as much of each as this tool reads.
///
/// Deliberately partial. Every struct here is `deny_unknown_fields`-free so the
/// server can grow a field without breaking an installed binary — a CLI is the
/// one client that is never redeployed alongside the API, and a strict decoder
/// would turn every additive change into a support question.

#[derive(Debug, Serialize, Deserialize)]
pub struct ProjectsPage {
    pub projects: Vec<Project>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Project {
    pub id: String,
    pub slug: String,
    pub name: String,
    #[serde(default)]
    pub environment_name: String,
    #[serde(default)]
    pub service_count: u32,
    #[serde(default)]
    pub online_count: u32,
    #[serde(default)]
    pub services: Vec<Service>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ServicesPage {
    pub services: Vec<Service>,
    #[serde(default)]
    pub edges: Vec<Edge>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Service {
    /// The service-environment id: what every other endpoint is keyed on.
    pub id: String,
    pub service_id: String,
    pub name: String,
    pub slug: String,
    pub kind: String,
    pub state: String,
    #[serde(default)]
    pub brand: Option<String>,
    #[serde(default)]
    pub host: Option<String>,
    #[serde(default)]
    pub repo_full_name: Option<String>,
    #[serde(default)]
    pub last_deployment_number: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Edge {
    pub from: String,
    pub to: String,
    pub label: String,
}

/// The canvas of a project: where each service sits, and what points at what.
///
/// A different shape from `ServicesPage` on purpose, and the server answers it
/// from a different route. That one is a service with its state, its origin and
/// its hostname; this one is a map, and everything on it is a coordinate.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Canvas {
    pub project_id: String,
    pub environment_id: String,
    pub nodes: Vec<CanvasNode>,
    #[serde(default)]
    pub edges: Vec<CanvasArrow>,
    /// Absent when the project holds no services at all.
    #[serde(default)]
    pub bounds: Option<CanvasBounds>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasNode {
    /// What every canvas write is keyed on — not the service-environment id.
    pub service_id: String,
    pub service_environment_id: String,
    pub name: String,
    pub slug: String,
    pub kind: String,
    pub state: String,
    pub x: i64,
    pub y: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasArrow {
    /// The consumer's slug: the arrow points away from here.
    pub from: String,
    pub to: String,
    pub from_service_id: String,
    pub to_service_id: String,
    #[serde(default)]
    pub keys: Vec<String>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct CanvasBounds {
    pub left: i64,
    pub top: i64,
    pub right: i64,
    pub bottom: i64,
}

/// One service's new position, as the canvas endpoint takes it.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasPlacement {
    pub service_id: String,
    pub x: i64,
    pub y: i64,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceDetail {
    pub service: ServiceIdentity,
    pub environment: ServiceEnvironment,
    #[serde(default)]
    pub domains: Vec<Domain>,
    /// The version serving right now: `status = 'active'`, and nothing else.
    #[serde(default)]
    pub active_deployment: Option<Deployment>,
    /// The version *on the machine* — serving, asleep, or fallen over.
    ///
    /// A sleeping service has this and not `active_deployment`, which is why
    /// the summary used to say nothing at all about the one service state that
    /// is normal here. Absent from a server older than the field, so the older
    /// one is still read when this is `None`.
    #[serde(default)]
    pub live_deployment: Option<Deployment>,
    /// What the platform read out of the repository, or absent before it has.
    #[serde(default)]
    pub capabilities: Option<ServiceCapabilities>,
    /// The format of the file this component is configured with, if any.
    #[serde(default)]
    pub config_format: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceIdentity {
    pub id: String,
    pub name: String,
    pub slug: String,
    pub kind: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceEnvironment {
    pub id: String,
    pub state: String,
    #[serde(default)]
    pub memory_mb: u32,
    #[serde(default)]
    pub cpus: f32,
    #[serde(default)]
    pub sleep_enabled: bool,
    /// Minutes without a request before the sweeper puts it to sleep. Zero
    /// from a server too old to send it, which the detail view reads as
    /// "unknown" rather than as "at once".
    #[serde(default)]
    pub sleep_after_minutes: u32,
    #[serde(default)]
    pub container_port: Option<u32>,
    #[serde(default)]
    pub health_path: Option<String>,
    /// `manual`, `detected`, or absent for a service nobody has answered for.
    #[serde(default)]
    pub health_path_origin: Option<String>,
    #[serde(default)]
    pub health_probe: Option<String>,
    /// What `auto` resolves to for this service: `http`, `tcp` or `none`.
    ///
    /// Sent resolved because a client cannot work it out — the rule needs the
    /// origin *and* the declared path, and only the server owns it.
    #[serde(default)]
    pub health_probe_resolved: Option<String>,
    #[serde(default)]
    pub health_timeout_seconds: Option<u32>,
    #[serde(default)]
    pub health_interval_seconds: Option<u32>,
    #[serde(default)]
    pub health_grace_seconds: Option<u32>,
    #[serde(default)]
    pub adopted: bool,
}

/// What a service turned out to offer, read from its repository.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceCapabilities {
    #[serde(default)]
    pub framework: Option<String>,
    #[serde(default)]
    pub framework_version: Option<String>,
    #[serde(default)]
    pub rendering: String,
    #[serde(default)]
    pub declared_port: Option<u32>,
    #[serde(default)]
    pub endpoints: Vec<CapabilityEndpoint>,
    /// True when it was read from the git tree, so it saw less.
    #[serde(default)]
    pub shallow: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CapabilityEndpoint {
    pub path: String,
    pub kind: String,
    /// The file it was read out of, so a wrong answer can be traced.
    #[serde(default)]
    pub evidence: String,
    #[serde(default)]
    pub confidence: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Deployment {
    pub id: String,
    pub number: u32,
    pub status: String,
    pub trigger: String,
    #[serde(default)]
    pub commit_sha: Option<String>,
    #[serde(default)]
    pub commit_subject: Option<String>,
    #[serde(default)]
    pub failure_message: Option<String>,
    pub created_at: String,
    #[serde(default)]
    pub finished_at: Option<String>,
}

/// An archive somebody uploaded, which is a service's code at one moment.
///
/// The digest is what a commit sha is to a repository — the thing that says two
/// versions are not the same one — and it is what the platform builds its cache
/// key from, so it is worth printing.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Upload {
    pub id: String,
    pub file_name: String,
    pub format: String,
    pub digest: String,
    pub size_bytes: u64,
    pub created_at: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UploadsPage {
    pub uploads: Vec<Upload>,
    /// Which of them the service builds from now. None before the first one.
    #[serde(default)]
    pub current: Option<String>,
}

/// The answer to an upload: the archive, and the deployment it started.
///
/// The deployment is absent when `--no-deploy` asked for one — the archive is
/// stored and nothing was built.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UploadAccepted {
    pub upload: Upload,
    #[serde(default)]
    pub deployment: Option<Deployment>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DeploymentsPage {
    pub deployments: Vec<Deployment>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DeploymentAccepted {
    pub deployment: Deployment,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DeploymentDetail {
    pub deployment: Deployment,
    pub pipeline: Pipeline,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pipeline {
    pub stages: Vec<Stage>,
    #[serde(default)]
    pub current_stage_id: Option<String>,
    pub finished: bool,
    pub succeeded: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Stage {
    pub id: String,
    pub label: String,
    pub state: String,
    #[serde(default)]
    pub started_at: Option<String>,
    #[serde(default)]
    pub finished_at: Option<String>,
    #[serde(default)]
    pub failure_message: Option<String>,
    /// How many log lines this step printed. Zero from a server without it.
    #[serde(default)]
    pub log_line_count: u32,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct VariablesPage {
    pub variables: Vec<Variable>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Variable {
    pub id: String,
    pub key: String,
    pub kind: String,
    #[serde(default)]
    pub preview: Option<String>,
    #[serde(default)]
    pub write_only: bool,
    /// Set once it is sealed: no value comes back and no write is accepted.
    #[serde(default)]
    pub sealed_at: Option<String>,
}

impl Variable {
    pub fn is_sealed(&self) -> bool {
        self.sealed_at.is_some()
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct RevealedVariable {
    pub value: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BackupsPage {
    #[serde(default)]
    pub schedules: Vec<String>,
    /// When the next scheduled copy is owed. Null when no schedule is on.
    #[serde(default)]
    pub next_at: Option<String>,
    /// False for a service with no volume, which has nothing to copy.
    #[serde(default)]
    pub supported: bool,
    /// Where every copy is also sent, as rclone names it. None when the copies
    /// stay on the machine — or when the instance predates the field.
    #[serde(default)]
    pub remote: Option<String>,
    #[serde(default)]
    pub backups: Vec<Backup>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Backup {
    pub id: String,
    /// Null for a copy somebody asked for, which is what exempts it from retention.
    #[serde(default)]
    pub schedule: Option<String>,
    pub status: String,
    #[serde(default)]
    pub size_bytes: u64,
    #[serde(default)]
    pub locked: bool,
    #[serde(default)]
    pub failure_message: Option<String>,
    pub created_at: String,
    /// When the copy also landed off the machine; None while it is local only.
    #[serde(default)]
    pub replicated_at: Option<String>,
    /// Why the last upload failed, for a copy that stayed local.
    #[serde(default)]
    pub replication_error: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct BackupTaken {
    pub backup: Backup,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BackupSchedules {
    #[serde(default)]
    pub schedules: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DomainsPage {
    pub domains: Vec<Domain>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Domain {
    pub id: String,
    pub host: String,
    pub kind: String,
    pub state: String,
    #[serde(default)]
    pub dns_instructions: Option<String>,
    /// False while the service is private: the name is kept, nothing serves it.
    ///
    /// Defaulted to true so this tool keeps working against an instance older
    /// than the switch, where every domain it can see is a serving one.
    #[serde(default = "enabled_by_default")]
    pub enabled: bool,
    pub url: String,
    /// What the owner of a custom domain points their record at.
    ///
    /// Every one of these is defaulted, because this binary ships on its own
    /// schedule: a `fundaia` installed today talks to instances that predate
    /// custom domains, and a missing field must read as "that platform does not
    /// do this" rather than as a parse error.
    #[serde(default)]
    pub cname_target: Option<String>,
    /// The label a DNS panel asks for, never the whole hostname.
    #[serde(default)]
    pub dns_label: Option<String>,
    #[serde(default)]
    pub verification_error: Option<String>,
    /// Null for a generated hostname, which never had a journey to draw.
    #[serde(default)]
    pub steps: Option<Vec<DomainStep>>,
}

/// One stage of a custom domain's journey, as the server decided it.
///
/// Derived there and printed here, never re-derived: the panel, this and the
/// MCP tool must not have three opinions about whether a domain is ready.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DomainStep {
    pub name: String,
    pub state: String,
    pub detail: String,
}

fn enabled_by_default() -> bool {
    true
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UsagePage {
    pub samples: Vec<UsageSample>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageSample {
    pub at: String,
    pub cpu_millicores: u32,
    pub memory_bytes: u64,
    pub memory_limit_bytes: u64,
}

/// The four counts a prompt spends, wherever they are added up.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenCounts {
    #[serde(default)]
    pub input_tokens: u64,
    #[serde(default)]
    pub output_tokens: u64,
    #[serde(default)]
    pub cache_read_tokens: u64,
    #[serde(default)]
    pub cache_creation_tokens: u64,
}

impl TokenCounts {
    pub fn total(&self) -> u64 {
        self.input_tokens + self.output_tokens + self.cache_read_tokens + self.cache_creation_tokens
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageTotals {
    #[serde(default)]
    pub prompts: u64,
    /// Dollars × 1e6, whole. Divided once, where it is printed.
    #[serde(default)]
    pub cost_micros: u64,
    #[serde(default)]
    pub duration_millis: u64,
    #[serde(default)]
    pub average_cost_micros: u64,
    #[serde(flatten)]
    pub tokens: TokenCounts,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsagePrompt {
    pub id: String,
    pub at: String,
    pub model: String,
    #[serde(default)]
    pub cost_micros: u64,
    #[serde(default)]
    pub duration_ms: u64,
    #[serde(default)]
    pub turns: u32,
    #[serde(flatten)]
    pub tokens: TokenCounts,
}

/// What an agent component has spent, over a window and over its whole life.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsumptionPage {
    pub range: String,
    /// False for every service that keeps no ledger, which is all but the agent.
    pub available: bool,
    pub totals: UsageTotals,
    pub lifetime: UsageTotals,
    #[serde(default)]
    pub since: Option<String>,
    #[serde(default)]
    pub recent: Vec<UsagePrompt>,
}

/// How a window's requests ended, in the three numbers worth telling apart.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OutcomeCounts {
    #[serde(default)]
    pub answered: u64,
    #[serde(default)]
    pub failed: u64,
    #[serde(default)]
    pub rejected: u64,
}

/// One request an agent component received, however it ended.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentRequest {
    pub id: String,
    pub at: String,
    pub model: String,
    /// `answered`, `failed` or `rejected`.
    pub outcome: String,
    /// Why it failed or was refused, in the component's own vocabulary.
    #[serde(default)]
    pub detail: Option<String>,
    /// `prompt` for an application's question, `repo-job` for the autofix.
    #[serde(default)]
    pub route: String,
    /// The opening of the prompt. Empty when the component keeps none.
    #[serde(default)]
    pub prompt_excerpt: String,
    #[serde(default)]
    pub prompt_chars: u64,
    #[serde(default)]
    pub images: u32,
    #[serde(default)]
    pub queued_ms: u64,
    #[serde(default)]
    pub duration_ms: u64,
    #[serde(default)]
    pub turns: u32,
    #[serde(default)]
    pub cost_micros: u64,
}

/// One request the component is working on at this instant.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LiveRequest {
    pub id: String,
    #[serde(default)]
    pub route: String,
    #[serde(default)]
    pub model: String,
    #[serde(default)]
    pub prompt_excerpt: String,
    /// Absent while it is still waiting for a slot.
    #[serde(default)]
    pub started_at: Option<String>,
    pub waiting_since: String,
}

/// What the container says it is doing right now.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LiveView {
    #[serde(default)]
    pub running: u32,
    #[serde(default)]
    pub queued: u32,
    #[serde(default)]
    pub max_concurrent: u32,
    #[serde(default)]
    pub max_queued: u32,
    #[serde(default)]
    pub requests: Vec<LiveRequest>,
}

/// What an agent has been asked to do, and what it is doing now.
///
/// `live` is `None` when the container could not be asked at all — asleep,
/// never deployed, or silent — which is a different fact from "nothing is
/// running" and is printed differently.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentActivityPage {
    pub range: String,
    /// False for every service that keeps no ledger, which is all but the agent.
    pub available: bool,
    #[serde(default)]
    pub counts: OutcomeCounts,
    #[serde(default)]
    pub requests: u64,
    #[serde(default)]
    pub answered_percent: u32,
    #[serde(default)]
    pub entries: Vec<AgentRequest>,
    #[serde(default)]
    pub live: Option<LiveView>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct AutofixPage {
    pub runs: Vec<AutofixRun>,
}

/// One attempt at fixing one incident.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutofixRun {
    pub id: String,
    pub status: String,
    pub step: String,
    pub model: String,
    #[serde(default)]
    pub diagnosis: Option<String>,
    #[serde(default, rename = "pullRequestUrl")]
    pub pull_request_url: Option<String>,
    #[serde(default, rename = "costMicros")]
    pub cost_micros: i64,
    #[serde(default, rename = "failureMessage")]
    pub failure_message: Option<String>,
    #[serde(rename = "startedAt")]
    pub started_at: String,
}

#[derive(Debug, Clone, Deserialize)]
pub struct IncidentsPage {
    pub incidents: Vec<Incident>,
}

/// A failure a service keeps printing, folded by shape and counted.
///
/// `shape` rather than `sample_message` is what a table draws: the sample is one
/// arbitrary occurrence and may name a person or a row, while the shape has all
/// of that replaced already.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Incident {
    pub id: String,
    pub shape: String,
    #[serde(default, rename = "sampleMessage")]
    pub sample_message: String,
    pub level: String,
    pub occurrences: u64,
    #[serde(rename = "firstSeenAt")]
    pub first_seen_at: String,
    #[serde(rename = "lastSeenAt")]
    pub last_seen_at: String,
    #[serde(default, rename = "lastTraceId")]
    pub last_trace_id: Option<String>,
    pub status: String,
}

/// What the platform can and cannot read of a service's repository.
#[derive(Debug, Serialize, Deserialize)]
pub struct RepositoryAccessPage {
    #[serde(default)]
    pub request: Option<RepositoryAccessRequest>,
    #[serde(default)]
    pub history: Vec<RepositoryAccessRequest>,
}

/// A repository the platform was refused, and the favour being asked for it.
///
/// `state` is the platform's own word — `pending` (nobody knows an address for
/// the owner), `sent`, `granted`, `expired` — and never a sentence, for the
/// reason an approval's `reason` is not one.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepositoryAccessRequest {
    pub id: String,
    #[serde(rename = "repoFullName")]
    pub repo_full_name: String,
    #[serde(rename = "ownerLogin")]
    pub owner_login: String,
    #[serde(default, rename = "ownerName")]
    pub owner_name: Option<String>,
    #[serde(default, rename = "installedOnAccount")]
    pub installed_on_account: bool,
    #[serde(default)]
    pub email: Option<String>,
    pub state: String,
    #[serde(rename = "detectedAt")]
    pub detected_at: String,
    #[serde(default, rename = "sentAt")]
    pub sent_at: Option<String>,
    #[serde(default, rename = "openedAt")]
    pub opened_at: Option<String>,
    #[serde(default, rename = "grantedAt")]
    pub granted_at: Option<String>,
}

/// What asking answers with, the link included.
///
/// The URL comes back so it can be copied — which is what saves the flow when
/// delivery is slow or the address had a typo in it. It is the credential that
/// grants somebody's repository, so it is printed on request and never stored.
#[derive(Debug, Serialize, Deserialize)]
pub struct SentRepositoryAccess {
    pub request: RepositoryAccessRequest,
    #[serde(rename = "approveUrl")]
    pub approve_url: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ApprovalsPage {
    pub approvals: Vec<Approval>,
}

/// A commit held at the door because whoever pushed it is not in the workspace.
///
/// `reason` is the platform's own word — `outside-workspace`, `unlinked-commit`
/// or `unverifiable` — and never a sentence: the three surfaces say it
/// differently, and a sentence composed on the server would be the web's.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Approval {
    pub id: String,
    #[serde(rename = "serviceEnvironmentId")]
    pub service_environment_id: String,
    #[serde(rename = "commitSha")]
    pub commit_sha: String,
    #[serde(default, rename = "commitSubject")]
    pub commit_subject: Option<String>,
    #[serde(default, rename = "authorLogin")]
    pub author_login: Option<String>,
    pub reason: String,
    pub state: String,
    #[serde(rename = "requestedAt")]
    pub requested_at: String,
    #[serde(default, rename = "deploymentId")]
    pub deployment_id: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LogPage {
    pub lines: Vec<LogLine>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogLine {
    pub sequence: u64,
    /// Absent from an older server; the column is held blank rather than
    /// shifting everything left for a log that predates it.
    #[serde(default)]
    pub at: Option<String>,
    #[serde(default)]
    pub stream: String,
    #[serde(default)]
    pub level: String,
    pub message: String,
    /// Which deployment step printed it; absent from an older server.
    #[serde(default)]
    pub stage: Option<String>,
    /// The request this line belongs to, when the service printed one.
    ///
    /// Absent from an older server and null on a line carrying no trace, which
    /// are two different facts that read the same here on purpose: neither one
    /// gives this line a trace to follow.
    #[serde(default, rename = "traceId")]
    pub trace_id: Option<String>,
}

/// One state change off `/api/infra/stream`.
///
/// Every field but `kind` is optional because the endpoint carries several
/// shapes down one socket — a deployment moving, a variable being written, a
/// colleague opening a field — and a client that refused to parse the ones it
/// does not draw would stop working the day a sixth is added.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InfraEvent {
    pub kind: String,
    #[serde(default)]
    pub project_id: String,
    #[serde(default)]
    pub service_environment_id: Option<String>,
    #[serde(default)]
    pub deployment_id: Option<String>,
    #[serde(default)]
    pub status: Option<String>,
    #[serde(default)]
    pub state: Option<String>,
    #[serde(default)]
    pub trigger: Option<String>,
    #[serde(default)]
    pub number: Option<u32>,
    #[serde(default)]
    pub service_name: Option<String>,
    #[serde(default)]
    pub commit_sha: Option<String>,
    #[serde(default)]
    pub commit_subject: Option<String>,
    /// The variable's name on a `variable-changed`. Never its value.
    #[serde(default)]
    pub key: Option<String>,
    #[serde(default)]
    pub action: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ConnectionCandidates {
    pub candidates: Vec<ConnectionCandidate>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ConnectionCandidate {
    pub id: String,
    pub name: String,
    pub summary: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ConnectionMade {
    pub connection: Connection,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Connection {
    pub provider_name: String,
    pub keys: Vec<String>,
    pub summary: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct TemplatesPage {
    pub templates: Vec<Template>,
    /// How the catalogue groups itself. Decided on the server so this and the
    /// canvas present it the same way.
    #[serde(default)]
    pub categories: Vec<TemplateCategory>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct TemplateCategory {
    pub id: String,
    pub label: String,
    pub summary: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Template {
    pub key: String,
    pub display_name: String,
    pub image: String,
    /// Defaulted so a newer CLI keeps parsing an older server's answer.
    #[serde(default)]
    pub category: String,
    #[serde(default)]
    pub summary: String,
    #[serde(default)]
    pub memory_mb: u32,
    /// What the component asks before it can be created, for the one that
    /// asks anything: Claude Code. Absent on every other entry, and on a
    /// server from before the setup existed.
    #[serde(default)]
    pub setup: Option<ClaudeCodeSetupOffer>,
}

/// A model or an effort level, as the catalogue describes it.
#[derive(Debug, Serialize, Deserialize)]
pub struct ClaudeOption {
    pub id: String,
    pub label: String,
    #[serde(default)]
    pub summary: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClaudeCodeSetupOffer {
    #[serde(default)]
    pub models: Vec<ClaudeOption>,
    #[serde(default)]
    pub efforts: Vec<ClaudeOption>,
    #[serde(default)]
    pub default_model: String,
    #[serde(default)]
    pub default_effort: String,
    /// Whether this account may leave the token out and run on the instance's own.
    #[serde(default)]
    pub token_optional: bool,
}

/// What a Claude Code component runs on: `GET …/agent`.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentSetup {
    pub model: String,
    pub effort: String,
    pub credential: AgentCredential,
    /// Whether this account is asked for a token at all. The instance owner never is.
    #[serde(default)]
    pub token_optional: bool,
    #[serde(default)]
    pub models: Vec<ClaudeOption>,
    #[serde(default)]
    pub efforts: Vec<ClaudeOption>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AgentCredential {
    /// Whether the service holds a token at all. Never the token.
    pub configured: bool,
    /// The instance's own, sealed: the container reads it and nobody else can.
    #[serde(default)]
    pub sealed: bool,
}

/// What `fundaia agent` changes. A field left `None` is a setting left alone.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentSetupPatch {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup_token: Option<String>,
}

impl AgentSetupPatch {
    pub fn is_empty(&self) -> bool {
        self.model.is_none() && self.effort.is_none() && self.setup_token.is_none()
    }
}

/// The three things a Claude Code component is created with, beside the service.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClaudeCodeSetupRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup_token: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effort: Option<String>,
}

/// The three steps of letting a terminal in, as the server describes them.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StartedAuthorization {
    pub user_code: String,
    pub device_secret: String,
    pub verification_uri: String,
    pub verification_uri_complete: String,
    pub interval_seconds: u64,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CollectedAuthorization {
    pub status: String,
    #[serde(default)]
    pub token: Option<String>,
}

/// What the instance calls itself, so a stale binary can say so.
#[derive(Debug, Serialize, Deserialize)]
pub struct ServerVersion {
    pub platform: String,
    #[serde(default)]
    pub revision: Option<String>,
    #[serde(default)]
    pub modules: std::collections::BTreeMap<String, String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Principal {
    pub principal: Option<PrincipalIdentity>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PrincipalIdentity {
    pub id: String,
    pub display_name: String,
}

/// The one thing this tool sends that is not a bare field or two.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NewService {
    pub name: String,
    pub source_kind: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repo_full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub template_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub connect_to: Vec<String>,
    /// Omitted means the server deploys it, which is what creating one asks for.
    /// Sent only to say no, so an older instance behaves as it always did.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deploy_now: Option<bool>,
    /// Only for `claude-code`; an older server ignores an unknown key.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub claude: Option<ClaudeCodeSetupRequest>,
}

// ------------------------------------------------------------- workspaces

#[derive(Debug, Serialize, Deserialize)]
pub struct WorkspacesPage {
    pub workspaces: Vec<Workspace>,
}

/// A place several people share, holding several projects.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Workspace {
    pub id: String,
    pub name: String,
    pub slug: String,
    /// What the caller is in it. Null for the instance owner, who is in none.
    #[serde(default)]
    pub role: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct MembersPage {
    pub members: Vec<Member>,
}

/// The prepaid balance the agents of a space run on.
///
/// Every figure is in micro-euros, the way the rest of the money in this API
/// travels: a prompt costs thousandths of a cent and floats of that size add up
/// to a total nobody can reconcile.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Credits {
    pub balance_micros: i64,
    pub added_micros: i64,
    pub spent_micros: i64,
    #[serde(default)]
    pub last_top_up_at: Option<String>,
    /// The share of what was bought that is left, or null before any was.
    #[serde(default)]
    pub remaining_percent: Option<i64>,
    #[serde(default)]
    pub running_low: bool,
    #[serde(default)]
    pub may_run_agent: bool,
    #[serde(default)]
    pub packs: Vec<CreditPack>,
    #[serde(default)]
    pub history: Vec<CreditEntry>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditPack {
    pub key: String,
    pub label: String,
    pub price_cents: i64,
    pub credit_micros: i64,
}

/// One movement: a top-up, or a prompt that spent part of one.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditEntry {
    pub id: String,
    pub kind: String,
    /// Positive added credit, negative spent it.
    pub amount_micros: i64,
    pub detail: String,
    pub created_at: String,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Member {
    pub user_id: String,
    pub role: String,
    #[serde(default)]
    pub display_name: Option<String>,
    #[serde(default)]
    pub github_login: Option<String>,
    #[serde(default)]
    pub email: Option<String>,
    /// When they were last around. Absent from an older server, and null for
    /// somebody who has not been back since the platform started recording it.
    #[serde(default)]
    pub last_seen_at: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ActivityPage {
    pub activity: Vec<ActivityEntry>,
}

/// One thing somebody did to a project.
///
/// The sentence arrives already written: `describeActivity` runs on the server
/// so this tool and the web say the same thing about the same row, rather than
/// each inventing its own vocabulary for `(subject_kind, action)`.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActivityEntry {
    pub id: String,
    pub summary: String,
    #[serde(default)]
    pub category: String,
    pub at: String,
    pub actor: ActivityActor,
}

/// Somebody, or the platform itself.
///
/// `kind` is `platform` for the rows nobody asked for individually — a push
/// that deployed a branch, a copy the scheduler took — and the server fills
/// `display_name` with the product's name for those, so this table prints
/// `Fundaia` where it used to print `commit-watcher`. Defaulted because a
/// binary already installed may be talking to a server that predates the field.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActivityActor {
    pub id: String,
    #[serde(default)]
    pub kind: Option<String>,
    #[serde(default)]
    pub display_name: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct InvitationsPage {
    pub invitations: Vec<Invitation>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Invitation {
    pub id: String,
    pub email: String,
    pub role: String,
    pub status: String,
}

/// What creating one answers with, link included.
///
/// The link comes back so the terminal can print it: a person running this over
/// SSH is often the same person who would otherwise have to go and find the
/// email, and delivery is the part most likely to be slow or unconfigured.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SentInvitation {
    pub accept_url: String,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NewInvitation {
    pub email: String,
    pub role: String,
}

// ------------------------------------------------------- settings & capacity

/// What the machine has left.
///
/// Numbers rather than a verdict: the terminal asking is usually about to
/// decide how big to make the next service.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Capacity {
    pub total_memory_mb: u64,
    /// What is in use this second, which is what the machine is full or not
    /// on. Absent from a server that still counted reservations.
    #[serde(default)]
    pub used_memory_mb: Option<u64>,
    pub reserved_memory_mb: u64,
    /// What every row promises. Reported because people ask; decides nothing.
    pub committed_memory_mb: u64,
    pub available_memory_mb: u64,
    pub ports_in_use: u32,
    pub ports_total: u32,
    pub remaining_at_default_size: u32,
    pub running_low: bool,
}

/// The result of turning bucket encryption on or off.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EncryptionOutcome {
    pub enabled: bool,
    pub buckets: Vec<String>,
    /// Objects rewritten so what was already stored is covered too.
    pub re_encrypted: u32,
}

/// What a service answers on after publishing it, or taking it off.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExposureOutcome {
    pub domains: Vec<Domain>,
}

/// A PATCH of a service's settings: absent keys are left alone.
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SettingsPatch {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub memory_mb: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub replicas: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_directory: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_command: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_path: Option<String>,
    /// What to ask this service, above what its origin would suggest.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_probe: Option<String>,
    /// The whole wait. It has been a column since the first migration and had
    /// never reached this struct.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_timeout_seconds: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_interval_seconds: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_grace_seconds: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_expected_status: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub restart_policy: Option<String>,
    /// What the platform spends bringing a crashed service back. It has been a
    /// column since the first migration and was read by nothing until the
    /// recovery sweep existed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub restart_max_retries: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sleep_enabled: Option<bool>,
    /// The idle window, in minutes. Read by the sleep sweeper alone, so
    /// changing it never restarts the container.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sleep_after_minutes: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_deploy: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_enabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_ttl_seconds: Option<u32>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct VolumesPage {
    pub volumes: Vec<Volume>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct VolumeAttached {
    pub volume: Volume,
}

/// A directory that outlives the container it is mounted into.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Volume {
    pub id: String,
    pub name: String,
    pub mount_path: String,
    /// False until the next deployment picks it up, which is why attaching says
    /// so rather than pretending the service already has it.
    #[serde(default)]
    pub mounted: bool,
    /// What the plan reserves for it, in megabytes.
    #[serde(default)]
    pub size_limit_mb: u64,
    #[serde(default)]
    pub used_bytes: u64,
    /// Null until the platform has measured this volume at least once, which is
    /// the one thing that separates "empty" from "never looked at".
    #[serde(default)]
    pub measured_at: Option<String>,
    /// Computed on the server, so the terminal and the bar in the browser cannot
    /// disagree about whether a volume is full.
    #[serde(default)]
    pub occupancy_percent: Option<u32>,
    #[serde(default)]
    pub created_at: Option<String>,
}

/// The Containerfile a service builds with, and how it was arrived at.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Recipe {
    /// Which strategy wrote it: `nixpacks`, `dockerfile`, `static`…
    pub builder: String,
    /// `generated` until somebody edits it, and `edited` for ever after.
    pub source: String,
    pub containerfile: String,
    #[serde(default)]
    pub exposed_port: Option<u32>,
    #[serde(default)]
    pub notes: Vec<String>,
    #[serde(default)]
    pub warnings: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct EditedRecipe {
    pub source: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ProjectCreated {
    pub project: Project,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Disconnected {
    /// The keys of the variable references that stopped existing, which is
    /// what a connection was made of in the first place.
    ///
    /// A list, because that is what the server has always answered — this
    /// was declared as a count for a year and every `disconnect` ended in
    /// "could not read the answer" after the server had already done it.
    #[serde(default)]
    pub removed: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ImportedVariables {
    #[serde(default)]
    pub imported: u32,
}

/// One line of a `.env` on its way to the server.
#[derive(Debug, Serialize)]
pub struct VariableDraft {
    pub key: String,
    pub value: String,
    pub secret: bool,
}

/// The document a load balancer or a gateway is configured with.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceConfigPage {
    pub config: ServiceConfig,
    /// Routes pointing at services that no longer exist. The file is untouched.
    #[serde(default)]
    pub stale_targets: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceConfig {
    pub format: String,
    pub container_path: String,
    /// `edited` freezes it: the form stops overwriting the text from then on.
    pub source: String,
    pub content: String,
    #[serde(default)]
    pub warnings: Vec<String>,
    #[serde(default)]
    pub edited_at: Option<String>,
}

/// What the two writing endpoints answer with, which is only the document.
#[derive(Debug, Serialize, Deserialize)]
pub struct ServiceConfigResponse {
    pub config: ServiceConfig,
}

/// One line of the sign-in history, as `/api/auth/sign-ins` serialises it.
///
/// Every field is `#[serde(default)]` past the ones that identify the row: this
/// crate ships on its own schedule, so a binary installed today talks to a
/// server that will be newer than it — and a missing field must leave a gap in
/// a column rather than fail the whole command.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SignIn {
    pub id: String,
    pub at: String,
    pub method: String,
    pub outcome: String,
    pub client_address: String,
    #[serde(default)]
    pub device: Option<String>,
    #[serde(default)]
    pub detail: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct SignInPage {
    #[serde(rename = "signIns")]
    pub sign_ins: Vec<SignIn>,
}

/// A session that is open right now.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthSession {
    pub id: String,
    pub created_at: String,
    pub last_seen_at: String,
    #[serde(default)]
    pub client_address: Option<String>,
    #[serde(default)]
    pub device: Option<String>,
    #[serde(default)]
    pub current: bool,
    #[serde(default)]
    pub pending: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AuthSessionPage {
    pub sessions: Vec<AuthSession>,
}

/// What one commit changed, as `/api/infra/services/:id/commits/:sha` answers.
///
/// `unavailable` is a field rather than an error, the same way the web receives
/// it: a service built from an image has no commit and an instance with no
/// GitHub App cannot ask about one — neither is a failed request, and both have
/// a sentence of their own that this prints as it arrives.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommitChangeResponse {
    #[serde(default)]
    pub commit: Option<CommitChange>,
    #[serde(default)]
    pub unavailable: Option<CommitUnavailable>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommitUnavailable {
    pub reason: String,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommitChange {
    pub sha: String,
    pub subject: String,
    #[serde(default)]
    pub body: Option<String>,
    #[serde(default)]
    pub author: Option<CommitAccount>,
    #[serde(default)]
    pub author_name: Option<String>,
    #[serde(default)]
    pub committed_at: Option<String>,
    #[serde(default)]
    pub html_url: Option<String>,
    #[serde(default)]
    pub parents: Vec<String>,
    pub repo_full_name: String,
    pub additions: u32,
    pub deletions: u32,
    /// GitHub lists at most 300 files. True means the rest are missing.
    #[serde(default)]
    pub truncated: bool,
    pub files: Vec<CommitFile>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommitAccount {
    pub login: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommitFile {
    pub path: String,
    #[serde(default)]
    pub previous_path: Option<String>,
    pub status: String,
    pub additions: u32,
    pub deletions: u32,
    /// Null for a binary, and for a file too large for GitHub to send one.
    #[serde(default)]
    pub patch: Option<String>,
}