#![allow(dead_code)]
use serde::{Deserialize, Serialize};
#[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 favorite: bool,
#[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 {
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,
}
#[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>,
#[serde(default)]
pub bounds: Option<CanvasBounds>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasNode {
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 {
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,
}
#[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>,
#[serde(default)]
pub active_deployment: Option<Deployment>,
#[serde(default)]
pub live_deployment: Option<Deployment>,
#[serde(default)]
pub capabilities: Option<ServiceCapabilities>,
#[serde(default)]
pub config_format: Option<String>,
#[serde(default)]
pub project_environment: Option<Environment>,
}
#[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 maintenance: Option<MaintenanceState>,
#[serde(default)]
pub protection: Option<ProtectionState>,
#[serde(default)]
pub ip_allowlist: Option<IpAllowlistState>,
#[serde(default)]
pub rate_limit: Option<RateLimitState>,
#[serde(default)]
pub memory_mb: u32,
#[serde(default)]
pub cpus: f32,
#[serde(default)]
pub sleep_enabled: bool,
#[serde(default)]
pub sleep_after_minutes: u32,
#[serde(default)]
pub awake_schedule: Option<String>,
#[serde(default)]
pub awake_description: Option<String>,
#[serde(default)]
pub container_port: Option<u32>,
#[serde(default)]
pub health_path: Option<String>,
#[serde(default)]
pub health_path_origin: Option<String>,
#[serde(default)]
pub health_probe: Option<String>,
#[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,
}
#[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>,
#[serde(default)]
pub shallow: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CapabilityEndpoint {
pub path: String,
pub kind: String,
#[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>,
#[serde(default)]
pub no_cache: bool,
}
#[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>,
#[serde(default)]
pub current: Option<String>,
}
#[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>,
#[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,
#[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>,
#[serde(default)]
pub next_at: Option<String>,
#[serde(default)]
pub supported: bool,
#[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,
#[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,
#[serde(default)]
pub replicated_at: Option<String>,
#[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>,
#[serde(default = "enabled_by_default")]
pub enabled: bool,
pub url: String,
#[serde(default)]
pub cname_target: Option<String>,
#[serde(default)]
pub dns_label: Option<String>,
#[serde(default)]
pub verification_error: Option<String>,
#[serde(default)]
pub steps: Option<Vec<DomainStep>>,
}
#[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,
}
#[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,
#[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,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsumptionPage {
pub range: String,
pub available: bool,
pub totals: UsageTotals,
pub lifetime: UsageTotals,
#[serde(default)]
pub since: Option<String>,
#[serde(default)]
pub recent: Vec<UsagePrompt>,
}
#[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,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentRequest {
pub id: String,
pub at: String,
pub model: String,
pub outcome: String,
#[serde(default)]
pub detail: Option<String>,
#[serde(default)]
pub route: String,
#[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,
}
#[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,
#[serde(default)]
pub started_at: Option<String>,
pub waiting_since: String,
}
#[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>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentActivityPage {
pub range: String,
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>,
}
#[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>,
}
#[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,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RepositoryAccessPage {
#[serde(default)]
pub request: Option<RepositoryAccessRequest>,
#[serde(default)]
pub history: Vec<RepositoryAccessRequest>,
}
#[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>,
}
#[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>,
}
#[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,
#[serde(default)]
pub at: Option<String>,
#[serde(default)]
pub stream: String,
#[serde(default)]
pub level: String,
pub message: String,
#[serde(default)]
pub stage: Option<String>,
#[serde(default, rename = "traceId")]
pub trace_id: Option<String>,
}
#[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>,
#[serde(default)]
pub key: Option<String>,
#[serde(default)]
pub action: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub auto_rollback: Option<AutoRollbackNotice>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AutoRollbackNotice {
pub from: u32,
pub to: u32,
pub after_seconds: u64,
}
#[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>,
#[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,
#[serde(default)]
pub category: String,
#[serde(default)]
pub summary: String,
#[serde(default)]
pub memory_mb: u32,
#[serde(default)]
pub setup: Option<ClaudeCodeSetupOffer>,
}
#[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,
#[serde(default)]
pub token_optional: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentSetup {
pub model: String,
pub effort: String,
pub credential: AgentCredential,
#[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 {
pub configured: bool,
#[serde(default)]
pub sealed: bool,
}
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AutofixPatch {
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_service_environment_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_occurrences: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub daily_limit: Option<u32>,
}
impl AutofixPatch {
pub fn is_empty(&self) -> bool {
self.mode.is_none()
&& self.agent_service_environment_id.is_none()
&& self.model.is_none()
&& self.minimum_occurrences.is_none()
&& self.daily_limit.is_none()
}
}
#[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()
}
}
#[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>,
}
#[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>,
}
#[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,
}
#[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>,
#[serde(skip_serializing_if = "Option::is_none")]
pub deploy_now: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub claude: Option<ClaudeCodeSetupRequest>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct EnvironmentsPage {
pub environments: Vec<Environment>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Environment {
pub id: String,
pub name: String,
pub slug: String,
#[serde(default)]
pub is_default: bool,
#[serde(default)]
pub service_count: Option<u32>,
#[serde(default)]
pub expires_at: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct EnvironmentPage {
pub environment: Environment,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PromotedImage {
pub deployment_id: String,
pub number: u32,
#[serde(default)]
pub commit_sha: Option<String>,
#[serde(default)]
pub commit_subject: Option<String>,
#[serde(default)]
pub git_tag: Option<String>,
#[serde(default)]
pub image_reference: Option<String>,
#[serde(default)]
pub image_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StartedDeployment {
pub id: String,
pub number: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PromotionStep {
pub service_id: String,
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub source: Option<PromotedImage>,
#[serde(default)]
pub current: Option<PromotedImage>,
#[serde(default)]
pub deployment: Option<StartedDeployment>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PromotionPlan {
pub from: Environment,
pub to: Environment,
#[serde(default)]
pub services: Vec<PromotionStep>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CopiedVolume {
pub mount_path: String,
#[serde(default)]
pub bytes: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DataCopyStep {
pub service_id: String,
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub volumes: Vec<CopiedVolume>,
#[serde(default)]
pub unmatched: Vec<String>,
#[serde(default)]
pub safety_backups: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DataCopyPlan {
pub from: Environment,
pub to: Environment,
#[serde(default)]
pub services: Vec<DataCopyStep>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComparedSide {
pub kind: String,
#[serde(default)]
pub value: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComparedKey {
pub key: String,
pub kind: String,
#[serde(default)]
pub value: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DifferentKey {
pub key: String,
pub from: ComparedSide,
pub to: ComparedSide,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VariableDifference {
#[serde(default)]
pub only_in_from: Vec<ComparedKey>,
#[serde(default)]
pub only_in_to: Vec<ComparedKey>,
#[serde(default)]
pub different: Vec<DifferentKey>,
#[serde(default)]
pub same: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceDifference {
pub service_id: String,
pub name: String,
#[serde(default)]
pub from: Option<String>,
#[serde(default)]
pub to: Option<String>,
#[serde(flatten)]
pub difference: VariableDifference,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct EnvironmentComparison {
pub from: Environment,
pub to: Environment,
#[serde(default)]
pub shared: VariableDifference,
#[serde(default)]
pub services: Vec<ServiceDifference>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreatedEnvironment {
pub environment: Environment,
#[serde(default)]
pub copied_from: Option<Environment>,
#[serde(default)]
pub services: Vec<ServiceCopy>,
#[serde(default)]
pub variables: VariableCopy,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CopiedServicePage {
pub service: ServiceCopy,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceCopy {
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub service_environment_id: Option<String>,
#[serde(default)]
pub volumes: Vec<String>,
#[serde(default)]
pub host: Option<String>,
#[serde(default)]
pub notes: Vec<String>,
#[serde(default)]
pub variables: VariableCopy,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct VariableCopy {
#[serde(default)]
pub copied: Vec<String>,
#[serde(default)]
pub skipped: Vec<SkippedVariable>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SkippedVariable {
pub key: String,
pub reason: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkspacesPage {
pub workspaces: Vec<Workspace>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Workspace {
pub id: String,
pub name: String,
pub slug: String,
#[serde(default)]
pub role: Option<String>,
#[serde(default, rename = "requireSecondFactor")]
pub require_second_factor: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkspacePage {
pub workspace: Workspace,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MembersPage {
pub members: Vec<Member>,
}
#[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>,
#[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,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditEntry {
pub id: String,
pub kind: String,
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>,
#[serde(default)]
pub last_seen_at: Option<String>,
#[serde(default)]
pub second_factor: Option<bool>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ActivityPage {
pub activity: Vec<ActivityEntry>,
}
#[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,
}
#[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,
}
#[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,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Capacity {
pub total_memory_mb: u64,
#[serde(default)]
pub used_memory_mb: Option<u64>,
pub reserved_memory_mb: u64,
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,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EncryptionOutcome {
pub enabled: bool,
pub buckets: Vec<String>,
pub re_encrypted: u32,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExposureOutcome {
pub domains: Vec<Domain>,
}
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SettingsPatch {
#[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 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 pre_deploy_command: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub deploy_tag_pattern: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub health_path: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub health_probe: Option<String>,
#[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>,
#[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>,
#[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 image_auto_update: 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>,
#[serde(skip_serializing_if = "Option::is_none")]
pub awake_schedule: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub awake_timezone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub awake_prewarm: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback: Option<bool>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VolumesPage {
pub volumes: Vec<Volume>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VolumeAttached {
pub volume: Volume,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Volume {
pub id: String,
pub name: String,
pub mount_path: String,
#[serde(default)]
pub mounted: bool,
#[serde(default)]
pub size_limit_mb: u64,
#[serde(default)]
pub used_bytes: u64,
#[serde(default)]
pub measured_at: Option<String>,
#[serde(default)]
pub occupancy_percent: Option<u32>,
#[serde(default)]
pub created_at: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Recipe {
pub builder: String,
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 {
#[serde(default)]
pub removed: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ImportedVariables {
#[serde(default)]
pub imported: u32,
}
#[derive(Debug, Serialize)]
pub struct VariableDraft {
pub key: String,
pub value: String,
pub secret: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceConfigPage {
pub config: ServiceConfig,
#[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,
pub source: String,
pub content: String,
#[serde(default)]
pub warnings: Vec<String>,
#[serde(default)]
pub edited_at: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ServiceConfigResponse {
pub config: ServiceConfig,
}
#[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>,
}
#[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>,
}
#[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,
#[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,
#[serde(default)]
pub patch: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Workflow {
#[serde(rename = "repoFullName")]
pub repo_full_name: String,
pub branch: String,
pub path: String,
pub name: String,
#[serde(default, rename = "runsOnPush")]
pub runs_on_push: bool,
#[serde(default)]
pub manual: bool,
#[serde(default)]
pub schedules: Vec<String>,
#[serde(default, rename = "runsAfter")]
pub runs_after: Vec<String>,
#[serde(default)]
pub error: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowsPage {
pub workflows: Vec<Workflow>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowRun<Job = WorkflowJob> {
pub id: String,
pub number: u64,
#[serde(default, rename = "repoFullName")]
pub repo_full_name: Option<String>,
pub branch: String,
#[serde(rename = "commitSha")]
pub commit_sha: String,
#[serde(default, rename = "commitSubject")]
pub commit_subject: Option<String>,
#[serde(rename = "workflowPath")]
pub workflow_path: String,
#[serde(rename = "workflowName")]
pub workflow_name: String,
pub trigger: String,
#[serde(rename = "triggeredBy")]
pub triggered_by: String,
#[serde(default, rename = "triggeredByName")]
pub triggered_by_name: Option<String>,
pub status: String,
#[serde(default, rename = "failureMessage")]
pub failure_message: Option<String>,
#[serde(rename = "createdAt")]
pub created_at: String,
#[serde(default, rename = "finishedAt")]
pub finished_at: Option<String>,
#[serde(default = "Vec::new")]
pub jobs: Vec<Job>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowJobSummary {
pub key: String,
pub name: String,
pub status: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowStep {
pub name: String,
pub status: String,
#[serde(default, rename = "exitCode")]
pub exit_code: Option<i64>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowJob {
pub id: String,
pub key: String,
pub name: String,
pub status: String,
pub image: String,
#[serde(default, rename = "exitCode")]
pub exit_code: Option<i64>,
#[serde(default, rename = "failureMessage")]
pub failure_message: Option<String>,
#[serde(default)]
pub steps: Vec<WorkflowStep>,
#[serde(default)]
pub outputs: std::collections::BTreeMap<String, String>,
#[serde(default)]
pub summary: Option<String>,
#[serde(default, rename = "artifactBytes")]
pub artifact_bytes: Option<u64>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowRunsPage {
pub runs: Vec<WorkflowRun<WorkflowJobSummary>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowRunPage {
pub run: WorkflowRun,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowLogLine {
pub sequence: u64,
pub at: String,
#[serde(default)]
pub step: Option<u64>,
pub message: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WorkflowLogPage {
pub job: WorkflowJob,
pub lines: Vec<WorkflowLogLine>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DataOverview {
pub status: DataStatus,
pub relations: Vec<DataRelation>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DataStatus {
pub reachable: bool,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub database: Option<String>,
#[serde(default)]
pub engine: Option<String>,
#[serde(default)]
pub missing_variables: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DataRelation {
pub name: String,
pub kind: String,
pub column_count: u64,
#[serde(default)]
pub estimated_rows: Option<f64>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct QueryOutcome {
pub columns: Vec<String>,
pub rows: Vec<Vec<Option<String>>>,
pub has_more: bool,
pub limit: u64,
pub cells_truncated: bool,
pub rows_dropped: bool,
#[serde(default)]
pub failure: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExecutionOutcome {
pub committed: bool,
#[serde(default)]
pub rehearsal: Option<String>,
#[serde(default)]
pub command: Option<String>,
#[serde(default)]
pub affected_rows: Option<u64>,
pub columns: Vec<String>,
pub rows: Vec<Vec<Option<String>>>,
pub cells_truncated: bool,
pub rows_dropped: bool,
#[serde(default)]
pub failure: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct NextStep {
pub tool: String,
#[serde(default)]
pub arguments: serde_json::Map<String, serde_json::Value>,
}
#[derive(Debug, Deserialize)]
pub struct AttentionPage {
#[serde(default)]
pub items: Vec<AttentionItem>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct AttentionProject {
pub id: String,
pub name: String,
#[serde(default)]
pub slug: String,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AttentionService {
pub name: String,
#[serde(default)]
pub service_environment_id: String,
}
#[derive(Debug, Clone, Deserialize)]
pub struct AttentionItem {
pub project: AttentionProject,
#[serde(default)]
pub service: Option<AttentionService>,
#[serde(default)]
pub code: String,
pub severity: String,
pub message: String,
#[serde(default)]
pub next: Option<NextStep>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Finding {
#[serde(default)]
pub code: String,
pub severity: String,
pub message: String,
#[serde(default)]
pub next: Option<NextStep>,
}
#[derive(Debug, Deserialize)]
pub struct Diagnosis {
pub verdict: String,
pub summary: String,
#[serde(default)]
pub findings: Vec<Finding>,
}
#[derive(Debug, Deserialize)]
pub struct DiagnosisPage {
pub diagnosis: Diagnosis,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceHealth {
#[serde(default)]
pub service_environment_id: String,
pub name: String,
pub verdict: String,
#[serde(default)]
pub summary: String,
#[serde(default)]
pub findings: Vec<Finding>,
}
#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkflowHealth {
#[serde(default)]
pub running: u64,
#[serde(default)]
pub failing_workflows: Vec<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProjectHealth {
pub verdict: String,
pub summary: String,
#[serde(default)]
pub services: Vec<ServiceHealth>,
#[serde(default)]
pub workflows: WorkflowHealth,
#[serde(default)]
pub pending_approvals: u64,
}
#[derive(Debug, Deserialize)]
pub struct HealthPage {
pub health: ProjectHealth,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceProblem {
pub kind: String,
pub key: String,
#[serde(default)]
pub scope: String,
#[serde(default)]
pub service: Option<String>,
#[serde(default)]
pub service_environment_id: Option<String>,
pub reference: String,
#[serde(default)]
pub suggestion: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct VariableAuditPage {
#[serde(default)]
pub problems: Vec<ReferenceProblem>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LogMatch {
#[serde(flatten)]
pub line: LogLine,
#[serde(default)]
pub service: Option<String>,
#[serde(default)]
pub service_environment_id: Option<String>,
#[serde(default)]
pub deployment_number: Option<u32>,
}
#[derive(Debug, Deserialize)]
pub struct LogSearchPage {
#[serde(default)]
pub lines: Vec<LogMatch>,
}
#[derive(Debug, Deserialize)]
pub struct DependencyLink {
pub name: String,
#[serde(default)]
pub keys: Vec<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceDependencies {
#[serde(default)]
pub uses: Vec<DependencyLink>,
#[serde(default)]
pub used_by: Vec<DependencyLink>,
#[serde(default)]
pub redeploy_after_change: Vec<String>,
}
#[derive(Debug, Deserialize)]
pub struct DependenciesPage {
pub dependencies: ServiceDependencies,
}
#[derive(Debug, Deserialize)]
pub struct ManifestPage {
pub manifest: serde_json::Value,
}
#[derive(Debug, Deserialize)]
pub struct DeploymentChange {
pub field: String,
#[serde(default)]
pub before: Option<String>,
#[serde(default)]
pub after: Option<String>,
}
#[derive(Debug, Default, Deserialize)]
pub struct SecondsToLive {
#[serde(default)]
pub from: Option<i64>,
#[serde(default)]
pub to: Option<i64>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeploymentComparison {
pub from: u32,
pub to: u32,
pub same_code: bool,
pub same_variables: bool,
pub same_config: bool,
#[serde(default)]
pub changes: Vec<DeploymentChange>,
#[serde(default)]
pub seconds_to_live: SecondsToLive,
pub summary: String,
}
#[derive(Debug, Deserialize)]
pub struct ComparisonPage {
pub comparison: DeploymentComparison,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProbeResult {
pub state: String,
pub path: String,
pub reachable: bool,
#[serde(default)]
pub status: Option<u16>,
#[serde(default)]
pub latency_millis: Option<i64>,
#[serde(default)]
pub content_type: Option<String>,
#[serde(default)]
pub body_preview: Option<String>,
#[serde(default)]
pub error: Option<String>,
#[serde(default)]
pub hint: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct ProbePage {
pub probe: ProbeResult,
}
#[derive(Debug, Deserialize)]
pub struct WokenPage {
pub state: String,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkflowStats {
pub path: String,
pub name: String,
pub runs: u64,
pub succeeded: u64,
pub failed: u64,
#[serde(default)]
pub success_rate: Option<f64>,
#[serde(default)]
pub median_seconds: Option<f64>,
#[serde(default)]
pub slowest_seconds: Option<f64>,
#[serde(default)]
pub last_status: Option<String>,
#[serde(default)]
pub last_failure_at: Option<String>,
#[serde(default)]
pub flaky: bool,
#[serde(default)]
pub failing_streak: u64,
}
#[derive(Debug, Deserialize)]
pub struct WorkflowStatsPage {
#[serde(default)]
pub stats: Vec<WorkflowStats>,
}
#[derive(Debug, Deserialize)]
pub struct AutofixRunPage {
pub run: AutofixRun,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Vulnerability {
pub package: String,
#[serde(default)]
pub installed: String,
#[serde(default)]
pub fixed_in: Option<String>,
pub severity: String,
#[serde(default)]
pub advisory: Option<String>,
#[serde(default)]
pub title: String,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SecurityScan {
pub id: String,
#[serde(default)]
pub service_environment_id: String,
pub status: String,
#[serde(default)]
pub step: String,
#[serde(default)]
pub fix: bool,
#[serde(default)]
pub model: String,
#[serde(default)]
pub findings: Vec<Vulnerability>,
#[serde(default)]
pub summary: Option<String>,
#[serde(default)]
pub pull_request_url: Option<String>,
#[serde(default)]
pub pull_request_number: Option<u64>,
#[serde(default)]
pub cost_micros: i64,
#[serde(default)]
pub failure_message: Option<String>,
#[serde(default)]
pub started_by: Option<String>,
pub started_at: String,
#[serde(default)]
pub ended_at: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct SecurityScanPage {
pub scan: SecurityScan,
}
#[derive(Debug, Deserialize)]
pub struct SecurityScansPage {
#[serde(default)]
pub scans: Vec<SecurityScan>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LinkedIssue {
pub id: String,
#[serde(default)]
pub subject_kind: String,
#[serde(default)]
pub subject_id: String,
#[serde(default)]
pub repository: String,
pub number: u64,
pub url: String,
}
#[derive(Debug, Deserialize)]
pub struct IssuePage {
pub issue: LinkedIssue,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WebhooksPage {
pub webhooks: Vec<Webhook>,
#[serde(default)]
pub events: Vec<WebhookEventOption>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhookEventOption {
pub key: String,
pub label: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Webhook {
pub id: String,
pub name: String,
pub format: String,
pub url_hint: String,
#[serde(default)]
pub events: Vec<String>,
#[serde(default = "enabled_by_default")]
pub enabled: bool,
#[serde(default)]
pub last_delivery: Option<WebhookDelivery>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhookDelivery {
pub at: String,
#[serde(default)]
pub status: Option<u16>,
#[serde(default)]
pub delivered: bool,
#[serde(default)]
pub error: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreatedWebhook {
pub webhook: Webhook,
pub signing_secret: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WebhookPage {
pub webhook: Webhook,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WebhookTestPage {
pub delivery: WebhookDelivery,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FavoritePage {
pub favorite: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct EdgeAccessPage {
pub maintenance: MaintenanceState,
pub protection: ProtectionState,
#[serde(default, rename = "ipAllowlist")]
pub ip_allowlist: Option<IpAllowlistState>,
#[serde(default, rename = "rateLimit")]
pub rate_limit: Option<RateLimitState>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IpAllowlistState {
pub enabled: bool,
#[serde(default)]
pub entries: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RateLimitState {
pub enabled: bool,
#[serde(default)]
pub per_minute: Option<u32>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RequestWindow {
pub requests: Vec<InspectedRequest>,
pub summary: RequestSummary,
#[serde(default)]
pub capacity: u32,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RequestSummary {
pub total: u32,
#[serde(default)]
pub p50_millis: Option<u64>,
#[serde(default)]
pub p95_millis: Option<u64>,
#[serde(default)]
pub server_error_percent: Option<f64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InspectedRequest {
pub sequence: u64,
pub at: String,
pub method: String,
pub path: String,
pub status: u16,
pub duration_millis: u64,
#[serde(default)]
pub client_address: Option<String>,
#[serde(default)]
pub user_agent: Option<String>,
#[serde(default)]
pub cached: bool,
#[serde(default)]
pub woke: bool,
#[serde(default)]
pub web_socket: bool,
#[serde(default)]
pub blocked_by: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MaintenanceState {
pub enabled: bool,
#[serde(default)]
pub since: Option<String>,
#[serde(default)]
pub message: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ProtectionState {
pub enabled: bool,
#[serde(default)]
pub username: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SharedVariablesPage {
pub project: Vec<Variable>,
pub environment: SharedEnvironment,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SharedEnvironment {
pub name: String,
pub slug: String,
#[serde(default)]
pub variables: Vec<Variable>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsoleRun {
pub command: String,
pub exit_code: i32,
#[serde(default)]
pub stdout: String,
#[serde(default)]
pub stderr: String,
#[serde(default)]
pub truncated: bool,
#[serde(default)]
pub timed_out: bool,
#[serde(default)]
pub duration_millis: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ConsolePage {
pub run: ConsoleRun,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DirectoryListing {
#[serde(default)]
pub roots: Vec<String>,
pub root: String,
pub path: String,
#[serde(default)]
pub entries: Vec<FileEntry>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileEntry {
pub name: String,
pub kind: String,
#[serde(default)]
pub size_bytes: u64,
pub modified_at: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FilePreview {
pub path: String,
#[serde(default)]
pub size_bytes: u64,
#[serde(default)]
pub text: Option<String>,
#[serde(default)]
pub truncated: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ScheduledTask {
pub id: String,
pub name: String,
pub command: String,
pub schedule: String,
pub enabled: bool,
#[serde(default)]
pub next_run_at: Option<String>,
#[serde(default)]
pub last_run: Option<TaskRun>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TaskRun {
pub id: String,
pub trigger: String,
#[serde(default)]
pub triggered_by: String,
pub status: String,
pub started_at: String,
#[serde(default)]
pub finished_at: Option<String>,
#[serde(default)]
pub duration_millis: Option<i64>,
#[serde(default)]
pub exit_code: Option<i64>,
#[serde(default)]
pub output: String,
#[serde(default)]
pub reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TasksPage {
#[serde(default)]
pub tasks: Vec<ScheduledTask>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TaskPage {
pub task: ScheduledTask,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TaskRunsPage {
#[serde(default)]
pub runs: Vec<TaskRun>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TaskRunPage {
pub run: TaskRun,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ImageCheck {
pub outcome: String,
pub image: String,
#[serde(default)]
pub image_id: Option<String>,
#[serde(default)]
pub deployment_id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ImageCheckPage {
pub check: ImageCheck,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PreviewStatus {
pub enabled: bool,
#[serde(default)]
pub previews: Vec<Preview>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Preview {
pub environment: PreviewEnvironment,
pub repo_full_name: String,
pub number: u64,
pub branch: String,
#[serde(default)]
pub title: String,
pub created_at: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PreviewEnvironment {
pub id: String,
pub name: String,
pub slug: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ImportResult {
pub project: ImportedProject,
#[serde(default)]
pub services: Vec<ImportedService>,
#[serde(default)]
pub missing_secrets: Vec<MissingSecret>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ImportedProject {
pub id: String,
pub name: String,
pub slug: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ImportedService {
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub notes: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MissingSecret {
#[serde(default)]
pub service: Option<String>,
pub key: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServerCapacity {
pub hostname: String,
pub podman_version: String,
pub cpus: u64,
pub memory_total_mb: u64,
pub memory_available_mb: u64,
pub memory_used_percent: u64,
#[serde(default)]
pub disk_used_percent: Option<u64>,
pub containers_running: u64,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Server {
pub id: String,
pub name: String,
pub primary: bool,
pub address: String,
#[serde(default)]
pub region: Option<String>,
pub status: String,
pub schedulable: bool,
pub draining: bool,
#[serde(default)]
pub connection: Option<String>,
#[serde(default)]
pub capacity: Option<ServerCapacity>,
#[serde(default)]
pub last_seen_at: Option<String>,
#[serde(default)]
pub last_error: Option<String>,
#[serde(default = "failover_by_default")]
pub failover: bool,
#[serde(default)]
pub environments: Option<u64>,
#[serde(default)]
pub containers: Option<u64>,
}
fn failover_by_default() -> bool {
true
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ServerRef {
pub id: String,
pub name: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnvironmentMove {
pub id: String,
pub from: ServerRef,
pub to: ServerRef,
pub status: String,
pub step: String,
#[serde(default)]
pub error: Option<String>,
pub started_at: String,
#[serde(default)]
pub finished_at: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ServersPage {
pub servers: Vec<Server>,
#[serde(default)]
pub moves: Vec<EnvironmentMove>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ServerPage {
pub server: Server,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlacedEnvironment {
pub environment: String,
pub project: String,
pub project_slug: String,
pub services: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ServerDetail {
pub server: Server,
#[serde(default)]
pub environments: Vec<PlacedEnvironment>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DrainedEnvironment {
pub project_name: String,
pub environment_name: String,
#[serde(default)]
pub to: Option<String>,
#[serde(default)]
pub reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DrainPlan {
pub server: Server,
#[serde(default)]
pub moves: Vec<DrainedEnvironment>,
#[serde(default)]
pub staying: Vec<DrainedEnvironment>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MovePage {
#[serde(rename = "move")]
pub movement: EnvironmentMove,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PlacementServer {
pub name: String,
pub primary: bool,
pub status: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnvironmentPlacement {
pub server: PlacementServer,
#[serde(rename = "move", default)]
pub movement: Option<EnvironmentMove>,
#[serde(default)]
pub stays_on_primary: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RemovedServer {
pub removed: Server,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DeploymentFeed {
pub scope: String,
#[serde(default)]
pub deployments: Vec<FeedDeployment>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDeployment {
pub id: String,
pub number: u32,
pub status: String,
pub trigger: String,
#[serde(default)]
pub author: Option<FeedAuthor>,
#[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 duration_seconds: Option<u64>,
pub project: FeedProject,
pub service: FeedService,
pub environment: FeedEnvironment,
pub pipeline: Pipeline,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedAuthor {
pub id: String,
pub display_name: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FeedProject {
pub id: String,
pub name: String,
pub slug: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedService {
pub id: String,
#[serde(default)]
pub service_id: Option<String>,
pub name: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedEnvironment {
pub id: String,
pub name: String,
pub slug: String,
#[serde(default)]
pub is_default: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusPageAnswer {
pub status_page: StatusPageSettings,
#[serde(default)]
pub view: Option<StatusPageView>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusPageSettings {
pub project_id: String,
pub enabled: bool,
#[serde(default)]
pub title: String,
#[serde(default)]
pub shown_title: String,
#[serde(default)]
pub token: Option<String>,
#[serde(default)]
pub url: Option<String>,
#[serde(default)]
pub services: Vec<StatusPageChoice>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct StatusPageChoice {
pub id: String,
pub name: String,
pub included: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusPageView {
pub title: String,
pub status: String,
#[serde(default)]
pub uptime_percent: Option<f64>,
#[serde(default)]
pub services: Vec<StatusPageServiceView>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusPageServiceView {
pub name: String,
pub status: String,
#[serde(default)]
pub uptime_percent: Option<f64>,
}
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusPageChange {
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub services: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rotate_token: Option<bool>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BulkAnswer {
pub action: String,
pub environment: BulkEnvironment,
pub started: u32,
pub refused: u32,
pub results: Vec<BulkRow>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct BulkEnvironment {
pub id: String,
pub name: String,
pub slug: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BulkRow {
pub service_environment_id: String,
pub name: String,
pub outcome: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub deployment: Option<BulkDeployment>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct BulkDeployment {
pub id: String,
pub number: u32,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeployHook {
pub id: String,
pub name: String,
pub token_hint: String,
pub created_at: String,
#[serde(default)]
pub last_used_at: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DeployHooksPage {
pub hooks: Vec<DeployHook>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CreatedDeployHook {
pub hook: DeployHook,
pub token: String,
pub path: String,
pub url: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ComposeImport {
pub project: ImportedProject,
pub environment: Environment,
#[serde(default)]
pub created_project: bool,
#[serde(default)]
pub services: Vec<ComposeImportedService>,
#[serde(default)]
pub pending_variables: Vec<PendingVariable>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ComposeImportedService {
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub host: Option<String>,
#[serde(default)]
pub suggestion: Option<ComposeSuggestion>,
#[serde(default)]
pub notes: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ComposeSuggestion {
pub template_key: String,
pub display_name: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PendingVariable {
pub service: String,
pub key: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct StacksPage {
pub stacks: Vec<StackSummary>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StackSummary {
pub key: String,
pub display_name: String,
#[serde(default)]
pub summary: String,
#[serde(default)]
pub sign_in: String,
#[serde(default)]
pub memory_mb: u32,
#[serde(default)]
pub services: Vec<StackMember>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StackMember {
pub name: String,
#[serde(default)]
pub template_key: Option<String>,
#[serde(default)]
pub image: Option<String>,
#[serde(default)]
pub public: bool,
#[serde(default)]
pub memory_mb: u32,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PlacedStack {
pub project: ImportedProject,
pub environment: Environment,
pub stack: PlacedStackName,
#[serde(default)]
pub host: Option<String>,
#[serde(default)]
pub services: Vec<PlacedStackService>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlacedStackName {
pub key: String,
pub display_name: String,
#[serde(default)]
pub sign_in: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PlacedStackService {
pub name: String,
pub status: String,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub public: bool,
#[serde(default)]
pub notes: Vec<String>,
}